Класс StringBuilder.StringBuilder

final class StringBuilder(val underlying: StringBuilder) extends AbstractSeq[Символ] with ReusableBuilder[Символ, String] with IndexedSeq[Символ] with IndexedSeqOps[Символ, IndexedSeq, StringBuilder] with IterableFactoryDefaults[Символ, IndexedSeq] with CharSequence with Serializable

Строитель для изменяемой последовательности символов. Этот класс предоставляет API, в основном совместимый с java.lang.StringBuilder, за исключением случаев конфликтов с API коллекций Scala (например, метод reverse).

Этот Строитель может быть повторно использован после вызова result(), без промежуточного вызова clear(), для построения нескольких связанных результатов.

Конструкторы

Исходный код

def this()

Исходный код

def this(capacity: Целое число)

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

Исходный код

def this(str: String)

Создаёт строковый буфер с начальными символами, равными символам str.

Исходный код

def this(initCapacity: Целое число, initValue: String)

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

Конкретные методы

Исходный код

def ++=(s: String): StringBuilder.this.type

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

Исходный код

def addAll(s: String): StringBuilder.this.type

Перегруженная версия addAll, принимающая строку

Исходный код

def addOne(x: Символ): StringBuilder.this.type

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

Исходный код

def append(x: Any): StringBuilder

Добавляет строковое представление данного аргумента, которое преобразуется в строку с использованием String.valueOf.

Исходный код

def append(s: String): StringBuilder

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

Исходный код

def append(cs: CharSequence): StringBuilder

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

Исходный код

def append(s: StringBuilder): StringBuilder

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

Исходный код

def append(x: Boolean): StringBuilder

Добавить строковое представление заданного примитивного типа в эту последовательность. Аргумент преобразуется в строку с помощью String.valueOf.

Источник

def append(x: Byte): StringBuilder

Источник

def append(x: Short): StringBuilder

Источник

def append(x: Int): StringBuilder

Источник

def append(x: Long): StringBuilder

Источник

def append(x: Float): StringBuilder

Источник

def append(x: Double): StringBuilder

Источник

def append(x: Char): StringBuilder

Источник

def appendAll(xs: String): StringBuilder

Источник

def appendAll(xs: IterableOnce[Char]): StringBuilder

Добавляет все символы в заданном IterableOnce[Char] в эту последовательность.

Источник

def appendAll(xs: Array[Char]): StringBuilder

Добавляет все символы в заданном Array[Char] в эту последовательность.

Источник

def appendAll(xs: Array[Char], offset: Int, len: Int): StringBuilder

Добавляет часть заданного Array[Char] в эту последовательность.

Источник

def apply(i: Int): Char

Получение элемента по указанному индексу. Эта операция предоставляется для удобства в Seq. Не следует предполагать, что она эффективна, если у вас есть IndexedSeq.

Источник

def capacity: Int

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

Источник

def charAt(index: Int): Char

Возвращает символ по указанному индексу, считая с 0, как в массивах.

Источник

def clear(): Unit

Очищает содержимое этого билдера. После выполнения этого метода билдер не будет содержать элементов.

Если выполняется сразу после вызова result(), это позволяет создать новую инстанцию того же типа коллекции.

Источник

def delete(start: Int, end: Int): StringBuilder

Удаляет подпоследовательность символов из этой последовательности, начиная с указанного индекса начала (включительно) и до индекса конца (исключительно) или до конца строки, в зависимости от того, что произойдёт раньше.

Источник

def deleteCharAt(index: Int): StringBuilder.this.type

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

Источник

override def empty: StringBuilder

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

Источник

def ensureCapacity(newCapacity: Int): Unit

Убедитесь, что емкость по крайней мере равна заданному аргументу. Если аргумент больше текущей емкости, будет выделена новая область хранения размером, равным заданному аргументу или (2 * capacity + 2), что больше.

Источник

def indexOf(str: String): Int

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

Source

def indexOf(str: String, fromIndex: Int): Int

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

Source

def insert(index: Int, x: Any): StringBuilder

Вставляет строковое представление (через String.valueOf) заданного аргумента в эту последовательность по заданному индексу.

Source

def insert(index: Int, x: String): StringBuilder

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

Source

def insert(index: Int, x: Boolean): StringBuilder

Вызывает String.valueOf на данном примитивном значении и вставляет строку по указанному индексу.

Source

def insert(index: Int, x: Byte): StringBuilder

Source

def insert(index: Int, x: Short): StringBuilder

Source

def insert(index: Int, x: Int): StringBuilder

Source

def insert(index: Int, x: Long): StringBuilder

Source

def insert(index: Int, x: Float): StringBuilder

Source

def insert(index: Int, x: Double): StringBuilder

Source

def insert(index: Int, x: Char): StringBuilder

Source

def insertAll(index: Int, str: Array[Char], offset: Int, len: Int): StringBuilder

Вставляет подмассив из данного Array[Char] в указанный индекс этой последовательности.

Источник

def insertAll(index: Int, xs: IterableOnce[Char]): StringBuilder

Вставляет заданный Seq[Char] в эту последовательность в указанный индекс.

Источник

def insertAll(index: Int, xs: Array[Char]): StringBuilder

Вставляет заданный Array[Char] в эту последовательность в указанный индекс.

Источник

override def isEmpty: Boolean

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

Этот метод требуется для совместимости с JDK15+.

Источник

override def knownSize: Int

Источник

def lastIndexOf(str: String): Int

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

Источник

def lastIndexOf(str: String, fromIndex: Int): Int

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

Источник

def length: Int

Длина (количество элементов) строки сборщика. size является псевдонимом для length в Seq коллекциях.

Источник

def length_=(n: Int): Unit

Источник

def replace(start: Int, end: Int, str: String): StringBuilder

Заменяет подпоследовательность символов заданной строкой. Семантика такая же, как и в методе delete, но затем строка-аргумент вставляется в индекс 'start'.

Источник

def result(): String

Создает коллекцию из добавленных элементов.

После вызова result, поведение всех других методов не определено, за исключением clear(). Если вызывается clear(), тогда сборщик сбрасывается и может быть использован для построения другого экземпляра.

Источник

def reverseInPlace(): StringBuilder.this.type

Аналогично reverse, но деструктивно обновляет целевой StringBuilder.

Источник

def setCharAt(index: Int, ch: Char): StringBuilder.this.type

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

Источник

def setLength(len: Int): Unit

Устанавливает длину последовательности символов. Если текущая последовательность короче заданной длины, она дополняется нулями; если она длиннее, она усекается.

Источник

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

Для реализации CharSequence.

Источник

def substring(start: Int): String

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

target.substring(start) эквивалентно target.drop(start)

Источник

def substring(start: Int, end: Int): String

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

target.substring(start, end) эквивалентно target.slice(start, end).mkString

Источник

override def toArray[B >: Char](implicit ct: ClassTag[B]): Array[B]

Преобразовать коллекцию в массив.

Примечание к реализации: НЕ вызывайте Array.from из этого метода.

Источник

def toCharArray: Array[Char]

Возвращает содержимое этого StringBuilder в виде массива.

Источник

override def toString: String

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

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

Источник

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

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

Наследованные методы

Источник

final def ++[B >: Char](suffix: IterableOnce[B]): CC[B]

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

Источник

final override def ++:[B >: Char](prefix: IterableOnce[B]): CC[B]

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

Source

final def ++=(xs: IterableOnce[Char]): Growable.this.type

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

Source

final def +:[B >: Char](elem: B): CC[B]

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

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

Source

final def +=(elem: Char): Growable.this.type

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

Source

final def :+[B >: Char](elem: B): CC[B]

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

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

Source

final def :++[B >: Char](suffix: IterableOnce[B]): CC[B]

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

Source

def addAll(xs: IterableOnce[Char]): Growable.this.type

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

Source

final def addString(b: StringBuilder): 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

Source

final def addString(b: StringBuilder, sep: String): 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

Source

def addString(b: StringBuilder, start: String, sep: String, end: String): 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)

Source

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

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

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

Source

override def andThen[C](k: Char => C): PartialFunction[A, C]

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

Если тип функции в момент выполнения является PartialFunction, тогда используется другой метод andThen (обратите внимание на его предостережения).

Source

def appended[B >: Char](elem: B): CC[B]

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

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

Пример:

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)

Source

def appendedAll[B >: Char](suffix: IterableOnce[B]): CC[B]

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

Источник

def applyOrElse[A1 <: Int, B1 >: Char](x: A1, default: A1 => B1): B1

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

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

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

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

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

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

Источник

def canEqual(that: Any): Boolean

Метод, который должен вызываться из каждого хорошо спроектированного метода equals, который может быть переопределен в подклассе. См. Программирование на языке Scala, глава 28 для обсуждения и проектирования.

def chars(): IntStream

Источник

override def clone(): C

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

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

def codePoints(): IntStream

Источник

def collect[B](pf: PartialFunction[Char, B]): CC[B]

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

Источник

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

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

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

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

Источник

def combinations(n: Int): Iterator[C]

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

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

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

Источник

def compose[R](k: PartialFunction[R, Int]): PartialFunction[R, B]

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

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

Источник

def compose[A](g: A => Int): A => R

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

Source

final override def concat[B >: Char](suffix: IterableOnce[B]): CC[B]

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

Source

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

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

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

Source

def containsSlice[B >: Char](that: Seq[B]): Boolean

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

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

Source

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

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

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

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

Source

def copyToArray[B >: Char](xs: Array[B], start: Int): Int

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

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

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

Источник

def copyToArray[B >: Char](xs: Array[B]): Int

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

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

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

Источник

def corresponds[B](that: IterableOnce[B])(p: (Char, B) => Boolean): Boolean

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

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

Источник

def corresponds[B](that: Seq[B])(p: (Char, B) => Boolean): Boolean

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

Источник

def count(p: Char => Boolean): Int

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

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

Источник

def diff[B >: Char](that: Seq[B]): C

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

Источник

def distinct: C

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

Источник

def distinctBy[B](f: Char => B): C

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

Источник

override def drop(n: Int): C

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

Источник

override def dropRight(n: Int): C

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

Источник

def dropWhile(p: Char => Boolean): C

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

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

Источник

def elementWise: ElementWiseExtractor[A, B]

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

val firstChar: String => Option[Char] = _.headOption
Seq("foo", "bar", "baz") match {
  case firstChar.unlift.elementWise(c0, c1, c2) =>
    println(s"$c0, $c1, $c2") // Output: f, b, b
}

Источник

def endsWith[B >: Char](that: Iterable[B]): Boolean

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

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

Источник

override def equals(o: Any): Boolean

Универсальный метод равенства, определённый в AnyRef.

Источник

def exists(p: Char => Boolean): Boolean

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

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

Источник

def filter(pred: Char => Boolean): C

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

Источник

def filterNot(pred: Char => Boolean): C

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

Источник

def find(p: Char => Boolean): Option[A]

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

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

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

Source

def findLast(p: Char => Boolean): Option[A]

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

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

Source

def flatMap[B](f: Char => IterableOnce[B]): CC[B]

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

Например:

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

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

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

// lettersOf will return a Set[Char], not a Seq
def lettersOf(words: Seq[String]) = words.toSet flatMap ((word: String) => word.toSeq)

// xs will be an Iterable[Int]
val xs = Map("a" -> List(11,111), "b" -> List(22,222)).flatMap(_._2)

// ys will be a Map[Int, Int]
val ys = Map("a" -> List(1 -> 11,1 -> 111), "b" -> List(2 -> 22,2 -> 222)).flatMap(_._2)

Source

def flatten[B](implicit asIterable: Char => IterableOnce[B]): CC[B]

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

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

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)

Source

def fold[A1 >: Char](z: A1)(op: (A1, A1) => A1): A1

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

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

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

Source

def foldLeft[B](z: B)(op: (B, Char) => B): B

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

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

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

Источник

override def foldRight[B](z: B)(op: (Символ, B) => B): B

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

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

Источник

def forall(p: Символ => Boolean): Boolean

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

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

Источник

def foreach[U](f: Символ => U): Unit

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

Источник

def groupBy[K](f: Символ => K): Map[K, C]

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

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

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

Источник

def groupMap[K, B](key: Символ => K)(f: Символ => B): Map[K, CC[B]]

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

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

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

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

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

Исходный код

def groupMapReduce[K, B](key: Char => K)(f: Char => B)(reduce: (B, B) => B): Map[K, B]

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

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

def occurrences[A](as: Seq[A]): Map[A, Int] =
  as.groupMapReduce(identity)(_ => 1)(_ + _)

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

Исходный код

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

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

Исходный код

override def hashCode(): Int

Вычисляет значение хэш-кода для объекта.

Стандартный алгоритм хэширования зависит от платформы.

Обратите внимание, что для двух объектов допустимо иметь идентичные хэш-коды (o1.hashCode.equals(o2.hashCode)) но не быть равными (o1.equals(o2) возвращает false). Вырожденная реализация может всегда возвращать 0. Однако, требуется, чтобы если два объекта равны (o1.equals(o2) возвращает true ), у них должны быть идентичные хэш-коды (o1.hashCode.equals(o2.hashCode)). Поэтому при переопределении этого метода обязательно проверьте, что поведение согласуется с методом equals.

Исходный код

override def head: A

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

Исходный код

override def headOption: Option[A]

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

Исходный код

def indexOf[B >: Char](elem: B): Int

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

Исходный код

def indexOf[B >: Char](elem: B, from: Int): Int

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

Исходный код

def indexOfSlice[B >: Char](that: Seq[B]): Int

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

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

Исходный код

def indexOfSlice[B >: Char](that: Seq[B], from: Int): Int

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

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

Исходный код

def indexWhere(p: Char => Boolean): Int

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

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

Исходный код

def indexWhere(p: Char => Boolean, from: Int): Int

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

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

Исходный код

def indices: Range

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

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

Исходный код

def init: C

Часть коллекции без последнего элемента.

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

Исходный код

def inits: Iterator[C]

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

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

Исходный код

def intersect[B >: Char](that: Seq[B]): C

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

Исходный код

def isDefinedAt(idx: Int): Boolean

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

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

Исходный код

override def isTraversableAgain: Boolean

Проверяет, может ли эта коллекция быть многократно пройдена. Всегда true для Iterables и false для Iterators, если не переопределено.

Исходный код

override def iterableFactory: SeqFactory[IndexedSeq]

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

Исходный код

def iterator: Iterator[A]

Итератор может быть использован только один раз

Исходный код

override def last: A

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

Исходный код

def lastIndexOf[B >: Char](elem: B, end: Int): Int

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

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

Исходный код

def lastIndexOfSlice[B >: Char](that: Seq[B]): Int

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

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

Исходный код

def lastIndexOfSlice[B >: Char](that: Seq[B], end: Int): Int

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

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

Исходный код

def lastIndexWhere(p: Char => Boolean): Int

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

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

Исходный код

def lastIndexWhere(p: Char => Boolean, end: Int): Int

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

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

Исходный код

def lastOption: Option[A]

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

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

Исходный код

def lazyZip[B](that: Iterable[B]): LazyZip2[A, B, Iterable]

Аналогично zip за исключением того, что элементы в каждой коллекции не потребляются до тех пор, пока над возвращаемым LazyZip2 декоратором не вызывается строгая операция.

Вызовы lazyZip могут быть объединены для поддержки более высоких арностей (до 4) без расходов на построение и деструкцию промежуточных кортежей.

val xs = List(1, 2, 3)
val res = (xs lazyZip xs lazyZip xs lazyZip xs).map((a, b, c, d) => a + b + c + d)
// res == List(4, 8, 12)

Исходный код

final override def lengthCompare(that: Iterable[_]): Int

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

x <  0       if this.length <  that.size
x == 0       if this.length == that.size
x >  0       if this.length >  that.size

Исходный код

final override def lengthCompare(len: Int): Int

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

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

Исходный код

final def lengthIs: SizeCompareOps

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

Эти операции реализованы с использованием lengthCompare(Int) и позволяют использовать более удобочитаемые варианты:

this.lengthIs < len     // this.lengthCompare(len) < 0
this.lengthIs <= len    // this.lengthCompare(len) <= 0
this.lengthIs == len    // this.lengthCompare(len) == 0
this.lengthIs != len    // this.lengthCompare(len) != 0
this.lengthIs >= len    // this.lengthCompare(len) >= 0
this.lengthIs > len     // this.lengthCompare(len) > 0

Исходный код

def lift: A => Option[B]

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

Исходный код

override def map[B](f: Char => B): CC[B]

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

Исходный код

def mapInPlace(f: Char => Char): IndexedSeqOps.this.type

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

Исходный код

def mapResult[NewTo](f: String => NewTo): Builder[A, NewTo]

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

Исходный код

def max[B >: Char](implicit ord: Ordering[B]): A

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

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

Источник

def maxBy[B](f: Char => B)(implicit cmp: Ordering[B]): A

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

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

Источник

def maxByOption[B](f: Char => B)(implicit cmp: Ordering[B]): Option[A]

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

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

Источник

def maxOption[B >: Char](implicit ord: Ordering[B]): Option[A]

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

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

Источник

def min[B >: Char](implicit ord: Ordering[B]): A

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

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

Источник

def minBy[B](f: Char => B)(implicit cmp: Ordering[B]): A

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

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

Источник

def minByOption[B](f: Char => B)(implicit cmp: Ordering[B]): Option[A]

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

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

Источник

def minOption[B >: Char](implicit ord: Ordering[B]): Option[A]

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

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

Источник

final def mkString: String

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

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

Источник

final def mkString(sep: String): String

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

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

Источник

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

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

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

Источник

def nonEmpty: Boolean

Проверяет, не пуста ли коллекция.

Источник

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

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

Источник

def padTo[B >: Char](len: Int, elem: B): CC[B]

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

Источник

def partition(p: Char => Boolean): (C, C)

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

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

Источник

def partitionMap[A1, A2](f: Char => Either[A1, A2]): (CC[A1], CC[A2])

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

Пример:

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

Источник

def patch[B >: Char](from: Int, other: IterableOnce[B], replaced: Int): CC[B]

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

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

Источник

def permutations: Iterator[C]

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

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

Источник

override def prepended[B >: Char](elem: B): CC[B]

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

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

Пример:

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)

Источник

def prependedAll[B >: Char](prefix: IterableOnce[B]): CC[B]

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

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

Источник

def product[B >: Char](implicit num: Numeric[B]): B

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

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

Источник

def reduce[B >: Char](op: (B, B) => B): B

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

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

Источник

def reduceLeft[B >: Char](op: (B, Char) => B): B

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

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

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

Источник

def reduceLeftOption[B >: Char](op: (B, Char) => B): Option[B]

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

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

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

Источник

def reduceOption[B >: Char](op: (B, B) => B): Option[B]

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

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

Источник

def reduceRight[B >: Char](op: (Char, B) => B): B

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

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

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

Источник

def reduceRightOption[B >: Char](op: (Char, B) => B): Option[B]

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

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

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

Источник

override def reverse: C

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

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

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

Источник

override def reverseIterator: Iterator[A]

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

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

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

Источник

override protected def reversed: Iterable[A]

Источник

def runWith[U](action: Char => U): A => Boolean

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

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

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

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

Источник

def sameElements[B >: Char](that: IterableOnce[B]): Boolean

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

Источник

def scan[B >: Char](z: B)(op: (B, B) => B): CC[B]

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

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

Источник

def scanLeft[B](z: B)(op: (B, Char) => B): CC[B]

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

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

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

Источник

def scanRight[B](z: B)(op: (Char, B) => B): CC[B]

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

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

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

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

Пример:

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

Источник

override def search[B >: Char](elem: B, from: Int, to: Int)(implicit ord: Ordering[B]): SearchResult

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

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

Источник

override def search[B >: Char](elem: B)(implicit ord: Ordering[B]): SearchResult

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

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

Источник

def segmentLength(p: Char => Boolean, from: Int): Int

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

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

Источник

final def segmentLength(p: Char => Boolean): Int

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

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

Источник

final override def size: Int

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

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

Source

final override def sizeCompare(that: Iterable[_]): Int

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

x <  0       if this.size <  that.size
x == 0       if this.size == that.size
x >  0       if this.size >  that.size

Source

final override def sizeCompare(otherSize: Int): Int

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

x <  0       if this.size <  otherSize
x == 0       if this.size == otherSize
x >  0       if this.size >  otherSize

Source

final def sizeHint(coll: IterableOnce[_], delta: Int): Unit

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

Source

def sizeHint(size: Int): Unit

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

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

Source

final def sizeHintBounded(size: Int, boundingColl: Iterable[_]): Unit

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

Source

final def sizeIs: SizeCompareOps

Возвращает значение, содержащее операции сравнения размера этого набора данных с тестовым значением.

Эти операции реализованы на основе sizeCompare(Int) и позволяют использовать более читаемый синтаксис:

this.sizeIs < size     // this.sizeCompare(size) < 0
this.sizeIs <= size    // this.sizeCompare(size) <= 0
this.sizeIs == size    // this.sizeCompare(size) == 0
this.sizeIs != size    // this.sizeCompare(size) != 0
this.sizeIs >= size    // this.sizeCompare(size) >= 0
this.sizeIs > size     // this.sizeCompare(size) > 0

Source

override def slice(from: Int, until: Int): C

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

from <= indexOf(x) < until

Source

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

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

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

Source

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

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

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

Source

def sortBy[B](f: Char => B)(implicit ord: Ordering[B]): C

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

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

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

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

val words = "The quick brown fox jumped over the lazy dog".split(' ')
// this works because scala.Ordering will implicitly provide an Ordering[Tuple2[Int, Char]]
words.sortBy(x => (x.length, x.head))
res0: Array[String] = Array(The, dog, fox, the, lazy, over, brown, quick, jumped)

Источник

def sortInPlace[B >: Char]()(implicit ord: Ordering[B]): IndexedSeqOps.this.type

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

Источник

def sortInPlaceBy[B](f: Char => B)(implicit ord: Ordering[B]): IndexedSeqOps.this.type

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

Источник

def sortInPlaceWith(lt: (Char, Char) => Boolean): IndexedSeqOps.this.type

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

Источник

def sortWith(lt: (Char, Char) => Boolean): C

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

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

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

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

List("Steve", "Tom", "John", "Bob").sortWith(_.compareTo(_) < 0) =
List("Bob", "John", "Steve", "Tom")

Источник

def sorted[B >: Char](implicit ord: Ordering[B]): C

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

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

Источник

def span(p: Char => Boolean): (C, C)

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

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

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

Источник

override def splitAt(n: Int): (C, C)

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

Примечание: c splitAt n эквивалентно (но, возможно, более эффективно), чем (c take n, c drop n).

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

Источник

def startsWith[B >: Char](that: IterableOnce[B], offset: Int): Boolean

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

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

Источник

override def stepper[S <: Stepper[_]](implicit shape: StepperShape[Char, S]): S & EfficientSplit

Возвращает scala.collection.Stepper для элементов этой коллекции.

Stepper позволяет создавать поток Java для обработки коллекции, см. scala.jdk.StreamConverters. Для коллекций, содержащих примитивные значения, Stepper может использоваться как итератор, который не упаковывает элементы.

Неявный параметр scala.collection.StepperShape определяет тип результирующего Stepper в соответствии с типом элемента этой коллекции.

• Для коллекций целых Int, Short, Byte или Char, возвращается scala.collection.IntStepper

• Для коллекций Double или Float, возвращается scala.collection.DoubleStepper

• Для коллекций Long, возвращается scala.collection.LongStepper

• Для любого другого типа элемента возвращается scala.collection.AnyStepper

Обратите внимание, что этот метод переопределён в подклассах, и тип возвращаемого значения уточнён до S with EfficientSplit, например scala.collection.IndexedSeqOps.stepper. Для Stepper, помеченных scala.collection.Stepper.EfficientSplit, преобразователи в scala.jdk.StreamConverters позволяют создавать параллельные потоки, тогда как обычные Stepper можно преобразовать только в последовательные потоки.

Источник

def sum[B >: Char](implicit num: Numeric[B]): B

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

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

Источник

def tail: C

Остальная часть набора без его первого элемента.

Источник

def tails: Iterator[C]

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

Источник

override def take(n: Int): C

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

Источник

override def takeRight(n: Int): C

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

Источник

def takeWhile(p: Char => Boolean): C

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

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

Источник

override def tapEach[U](f: Char => U): C

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

Источник

def to[C1](factory: Factory[Char, C1]): C1

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

xs.to(List) xs.to(ArrayBuffer) xs.to(BitSet) // для xs: Iterable[Int]

Источник

final def toBuffer[B >: Char]: Buffer[B]

Источник

def toIndexedSeq: IndexedSeq[A]

Источник

def toList: List[A]

Источник

def toMap[K, V](implicit ev: Char <:< (K, V)): Map[K, V]

Источник

def toSeq: Seq[A]

Источник

def toSet[B >: Char]: Set[B]

Источник

def toVector: Vector[A]

Исходный код

def transpose[B](implicit asIterable: Char => Iterable[B]): CC[CC[B]]

Транспонирует это итерируемое множество итерируемых множеств в итерируемое множество итерируемых множеств.

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

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

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

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

Исходный код

def unapply(a: Int): Option[B]

Попытка извлечь B из A в выражении сопоставления с образцом.

Исходный код

def unzip[A1, A2](implicit asPair: Char => (A1, A2)): (CC[A1], CC[A2])

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

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

Исходный код

def unzip3[A1, A2, A3](implicit asTriple: Char => (A1, A2, A3)): (CC[A1], CC[A2], CC[A3])

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

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

Исходный код

def updated[B >: Char](index: Int, elem: B): CC[B]

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

Исходный код

override def view: IndexedSeqView[A]

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

Исходный код

def withFilter(p: Char => Boolean): WithFilter[A, CC]

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

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

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

Исходный код

def zip[B](that: IterableOnce[B]): CC[(A, B)]

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

Исходный код

def zipAll[A1 >: Char, B](that: Iterable[B], thisElem: A1, thatElem: B): CC[(A1, B)]

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

Исходный код

def zipWithIndex: CC[(A, Int)]

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

Конкретные поля

Исходный код

val underlying: StringBuilder