Класс scala.collection.immutable.WrappedString

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

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

Возвращает текущую строку, конкатенированную n раз.

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

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

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

Пример:

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

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

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

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

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

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

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

Пример:

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

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

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

A copy of the wrapped string with an element prepended.

Note that :-ending operators are right associative (see example). A mnemonic for +: vs. :+ is: the COLon goes on the COLlection side.

Also, the original wrapped string is not modified, so you will want to capture the result.

Example:

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)

Applies a binary operator to a start value and all elements of this traversable or iterator, going left to right.

Note: /: is alternate syntax for foldLeft; z /: xs is the same as xs foldLeft z.

Examples:

Note that the folding function used to compute b is equivalent to that used to compute 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

Note: will not terminate for infinite-sized collections.

Note: might return different results for different runs, unless the underlying collection type is ordered or the operator is associative and commutative.

A copy of this wrapped string with an element appended.

A mnemonic for +: vs. :+ is: the COLon goes on the COLlection side.

Example:

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)

Applies a binary operator to all elements of this traversable or iterator and a start value, going right to left.

Note: :\ is alternate syntax for foldRight; xs :\ z is the same as xs foldRight z.

Note: will not terminate for infinite-sized collections.

Note: might return different results for different runs, unless the underlying collection type is ordered or the operator is associative and commutative.

Examples:

Note that the folding function used to compute b is equivalent to that used to compute c.

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

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

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

Returns true if this is less than that

Returns true if this is less than or equal to that.

The expression x == that is equivalent to if (x eq null) that eq null else x.equals(that).

Returns true if this is greater than that.

Возвращает true, если this больше или равно that.

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

Пример:

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

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

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

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

Пример:

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

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

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

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

Пример:

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

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

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

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

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

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

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

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

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

Возвращает элемент по индексу n

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Результат сравнения this с операндом that.

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

Возвращает x, где:

x < 0 когда this < that x == 0 когда this == that x > 0 когда this > that

Результат сравнения this с операндом that.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Например:

def getWords(lines: Seq[String]): Seq[String] = lines flatMap (line => line split "\\W+")

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

// lettersOf will return a Seq[Char] of likely repeated letters, instead of a Set
def lettersOf(words: Seq[String]) = words flatMap (word => word.toSet)

// lettersOf will return a Set[Char], not a Seq
def lettersOf(words: Seq[String]) = words.toSet flatMap (word => 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)

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

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

val xs = List(
           Set(1, 2, 3),
           Set(1, 2, 3)
         ).flatten
// xs == List(1, 2, 3, 1, 2, 3)

val ys = Set(
           List(1, 2, 3),
           List(3, 2, 1)
         ).flatten
// ys == Set(1, 2, 3)

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

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

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

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

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

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

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

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

Использует базовую строку в качестве шаблона (подобно printf в C) и использует предоставленные аргументы для заполнения пробелов.

Интерпретация форматов описана в java.util.Formatter, с добавлением, что классы, производные от ScalaNumber (такие как scala.BigInt и scala.BigDecimal) распаковываются, чтобы передать тип, который Formatter понимает.

Подобно format(args*), но принимает начальный Locale параметр, который влияет на форматирование, как в java.lang.String's format.

Интерпретация форматов описана в java.util.Formatter, с добавлением, что классы, производные от ScalaNumber (такие как scala.BigInt и scala.BigDecimal) распаковываются, чтобы передать тип, который Formatter понимает.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Длина обернутой строки.

Примечание: xs.length и xs.size дают одинаковый результат.

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

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

Возвращает все строки в этой строке в итераторе, исключая завершающие символы конца строки; то есть, применяет .stripLineEnd ко всем возвращаемым строкам linesWithSeparators.

Возвращает все строки в этой строке в итераторе, исключая завершающие символы конца строки; то есть, применяет .stripLineEnd ко всем возвращаемым строкам linesWithSeparators.

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

Этот метод аналогичен s.split(EOL).toIterator, за исключением того, что все существующие символы конца строки сохраняются в результирующих строках, а пустая строка возвращает пустой итератор.

Символ конца строки — это один из

LF - перевод строки (0x0A) FF - разделитель страниц (0x0C)

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

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

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

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

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

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

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

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

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

Создаёт буфер билдера строк как буфер для данного класса

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Производит произведение элементов этого набора.

Вы можете добавить к строке .r(g1, ... , gn), превратив ее в Regex, с именами групп g1 до gn.

"""(\d\d)-(\d\d)-(\d\d\d\d)""".r("month", "day", "year") соответствует датам и предоставляет его подкомпоненты через группы с именами «месяц», «день» и «год».

Вы можете добавить к строке .r, превратив ее в Regex. Например,

"""A\w*""".r — это регулярное выражение для идентификаторов, начинающихся с A.

Уменьшает элементы этого итерируемого объекта или итератора с использованием указанного ассоциативного бинарного оператора.

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

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

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

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

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

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

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

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

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

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

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

Заменяет все буквальные вхождения literal на буквальную строку replacement. Этот метод эквивалентен java.lang.String#replace.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Пример:

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

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

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

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

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

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

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

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

from <= indexOf(x) < until

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

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

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

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

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

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

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

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

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

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

Разделяет эту строку вокруг символа разделителя

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

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

Если символ разделителя является суррогатным символом, разделение выполняется только по совпадающим суррогатным символам, если они не являются частью пары суррогатов

Поведение соответствует и реализуется через String.split(re: String)

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

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

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

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

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

Удалить символ конца строки из конца этой строки, если он есть.

Символ конца строки - один из

LF - символ перевода строки (0x0A шестнадцатеричный) FF - символ перевода страницы (0x0C шестнадцатеричный)

Если символ перевода строки LF предшествует символу возврата каретки CR (0x0D шестнадцатеричный), символ CR также удаляется (конвенция Windows).

Для каждой строки в этой строке:

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

Для каждой строки в этой строке:

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

Возвращает эту строку с удалённым заданным prefix. Если эта строка не начинается с prefix, она возвращается без изменений.

Возвращает эту строку с удалённым заданным suffix . Если эта строка не заканчивается на suffix, она возвращается без изменений.

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

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

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

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

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

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

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

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

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

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

Разбор как Byte (строка должна содержать только десятичные цифры и необязательный ведущий -).

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

Разбор как Double (окружающие пробелы удаляются с помощью trim).

Разбор как Float (окружающие пробелы удаляются с помощью trim).

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

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

Разбор как Int (строка должна содержать только десятичные цифры и необязательный ведущий -).

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

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

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

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

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

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

Разбор как Long (строка должна содержать только десятичные цифры и необязательный ведущий -).

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

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

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

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

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

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

Разбор как Short (строка должна содержать только десятичные цифры и необязательный ведущий -).

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

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

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

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

Преобразует данное обобщённое или итераторное множество в вектор.

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

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

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

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

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

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

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

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

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

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

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

Создаёт нестрогую (неявную) просмотрную версию среза последовательности.

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

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

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

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

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

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

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

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

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

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

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

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