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

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

Эквивалентно 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 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 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 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.

Test two objects for equality. 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

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

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

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

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

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

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

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

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

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

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

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

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

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

x < 0 если this < that x == 0 если this == that x > 0 если this > that

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Например:

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)

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

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

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

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

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

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

Применяет функцию 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 (@see java.lang.String.format).

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Длина строки.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Создаёт буфер StringBuilder в качестве билдера для этого класса

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

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

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

Для большинства типов наборов этот метод создаёт новый параллельный набор, копируя все элементы. Для этих наборов метод 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.

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

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

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

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

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

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

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

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

Примечание: Нейтральный элемент 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 являются бесконечными последовательностями, этот метод может не завершиться.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Создаёт нестрогую (non-strict) просмотр (view) этой последовательности.

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

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

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

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

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

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

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