kotlin.text
Package kotlin.text
Functions for working with text and regular expressions-
Types
interface Appendable | |
enum class CharCategory Represents the character general category in the Unicode specification. | |
enum class CharDirectionality Represents the Unicode directionality of a character. Character directionality is used to calculate the visual ordering of text. | |
object Charsets Constant definitions for the standard charsets. These charsets are guaranteed to be available on every implementation of the Java platform. | |
data class MatchGroup Represents the results from a single capturing group within a MatchResult of Regex. | |
interface MatchGroupCollection : Collection<MatchGroup?> Represents a collection of captured groups in a single match of a regular expression. | |
interface MatchNamedGroupCollection : MatchGroupCollection Extends MatchGroupCollection by introducing a way to get matched groups by name, when regex supports it. | |
interface MatchResult Represents the results from a single regular expression match. | |
class Regex Represents an immutable regular expression. | |
enum class RegexOption : FlagEnum Provides enumeration values to use to set regular expression options. | |
class StringBuilder : Appendable, CharSequence | |
object Typography Defines names for Unicode symbols used in proper Typography. |
Extensions for External Classes
Properties
val Char.category: CharCategory Returns a value indicating a character's general category. | |
val Char.directionality: CharDirectionality Returns the Unicode directionality property for the given character. | |
val CharSequence.indices: IntRange Returns the range of valid character indices for this char sequence. | |
val CharSequence.lastIndex: Int Returns the index of the last character in the char sequence or -1 if it is empty. | |
val CharSequence.size: Int |
Functions
fun Regex(pattern: String, option: RegexOption): Regex Creates a regular expression from the specified pattern string and the specified single option. fun Regex(pattern: String): Regex Creates a regular expression from the specified pattern string and the default options. | |
fun String( bytes: ByteArray, offset: Int, length: Int, charset: Charset ): String Converts the data from a portion of the specified array of bytes to characters using the specified character set and returns the conversion result as a string. fun String(bytes: ByteArray, charset: Charset): String Converts the data from the specified array of bytes to characters using the specified character set and returns the conversion result as a string. fun String( bytes: ByteArray, offset: Int, length: Int ): String Converts the data from a portion of the specified array of bytes to characters using the UTF-8 character set and returns the conversion result as a string. fun String(bytes: ByteArray): String Converts the data from the specified array of bytes to characters using the UTF-8 character set and returns the conversion result as a string. fun String(chars: CharArray): String Converts the characters in the specified array to a string. fun String( chars: CharArray, offset: Int, length: Int ): String Converts the characters from a portion of the specified array to a string. fun String( codePoints: IntArray, offset: Int, length: Int ): String Converts the code points from a portion of the specified Unicode code point array to a string. fun String(stringBuffer: StringBuffer): String Converts the contents of the specified StringBuffer to a string. fun String(stringBuilder: StringBuilder): String Converts the contents of the specified StringBuilder to a string. | |
fun CharSequence.all(predicate: (Char) -> Boolean): Boolean Returns | |
fun CharSequence.any(): Boolean Returns fun CharSequence.any(predicate: (Char) -> Boolean): Boolean Returns | |
fun <T : Appendable> T.append(vararg value: CharSequence?): T Appends all arguments to the given Appendable. fun StringBuilder.append( vararg value: String? ): StringBuilder fun StringBuilder.append(vararg value: Any?): StringBuilder Appends all arguments to the given StringBuilder. | |
fun CharSequence.asIterable(): Iterable<Char> Creates an Iterable instance that wraps the original char sequence returning its characters when being iterated. | |
fun CharSequence.asSequence(): Sequence<Char> Creates a Sequence instance that wraps the original char sequence returning its characters when being iterated. | |
fun <K, V> CharSequence.associate( transform: (Char) -> Pair<K, V> ): Map<K, V> Returns a Map containing key-value pairs provided by transform function applied to characters of the given char sequence. | |
fun <K> CharSequence.associateBy( keySelector: (Char) -> K ): Map<K, Char> Returns a Map containing the characters from the given char sequence indexed by the key returned from keySelector function applied to each character. fun <K, V> CharSequence.associateBy( keySelector: (Char) -> K, valueTransform: (Char) -> V ): Map<K, V> Returns a Map containing the values provided by valueTransform and indexed by keySelector functions applied to characters of the given char sequence. | |
fun <K, M : MutableMap<in K, in Char>> CharSequence.associateByTo( destination: M, keySelector: (Char) -> K ): M Populates and returns the destination mutable map with key-value pairs, where key is provided by the keySelector function applied to each character of the given char sequence and value is the character itself. fun <K, V, M : MutableMap<in K, in V>> CharSequence.associateByTo( destination: M, keySelector: (Char) -> K, valueTransform: (Char) -> V ): M Populates and returns the destination mutable map with key-value pairs, where key is provided by the keySelector function and and value is provided by the valueTransform function applied to characters of the given char sequence. | |
fun <K, V, M : MutableMap<in K, in V>> CharSequence.associateTo( destination: M, transform: (Char) -> Pair<K, V> ): M Populates and returns the destination mutable map with key-value pairs provided by transform function applied to each character of the given char sequence. | |
fun buildString( builderAction: StringBuilder.() -> Unit ): String Builds new string by populating newly created StringBuilder using provided builderAction and then converting it to String. fun buildString( capacity: Int, builderAction: StringBuilder.() -> Unit ): String Builds new string by populating newly created StringBuilder initialized with the given capacity using provided builderAction and then converting it to String. fun buildString( builderAction: StringBuilder.() -> Unit ): String Builds new string by populating newly created StringBuilder using provided builderAction and then converting it to String. fun buildString( capacity: Int, builderAction: StringBuilder.() -> Unit ): String Builds new string by populating newly created StringBuilder initialized with the given capacity using provided builderAction and then converting it to String. | |
fun String.capitalize(): String Returns a copy of this string having its first letter uppercased, or the original string, if it's empty or already starts with an upper case letter. | |
fun charset(charsetName: String): Charset Returns a named charset with the given charsetName name. | |
fun String.codePointAt(index: Int): Int Returns the character (Unicode code point) at the specified index. | |
fun String.codePointBefore(index: Int): Int Returns the character (Unicode code point) before the specified index. | |
fun String.codePointCount( beginIndex: Int, endIndex: Int ): Int Returns the number of Unicode code points in the specified text range of this String. | |
fun CharSequence.commonPrefixWith( other: CharSequence, ignoreCase: Boolean = false ): String Returns the longest string | |
fun CharSequence.commonSuffixWith( other: CharSequence, ignoreCase: Boolean = false ): String Returns the longest string | |
fun String.compareTo( other: String, ignoreCase: Boolean = false ): Int Compares two strings lexicographically, optionally ignoring case differences. | |
fun String.concat(str: String): String | |
operator fun CharSequence.contains( other: CharSequence, ignoreCase: Boolean = false ): Boolean Returns operator fun CharSequence.contains( char: Char, ignoreCase: Boolean = false ): Boolean Returns operator fun CharSequence.contains(regex: Regex): Boolean Returns | |
fun String.contentEquals(charSequence: CharSequence): Boolean Returns fun String.contentEquals( stringBuilder: StringBuffer ): Boolean Returns | |
fun CharSequence.count(): Int Returns the length of this char sequence. fun CharSequence.count(predicate: (Char) -> Boolean): Int Returns the number of characters matching the given predicate. | |
fun String.decapitalize(): String Returns a copy of this string having its first letter lowercased, or the original string, if it's empty or already starts with a lower case letter. | |
fun CharSequence.drop(n: Int): CharSequence Returns a subsequence of this char sequence with the first n characters removed. fun String.drop(n: Int): String Returns a string with the first n characters removed. | |
fun CharSequence.dropLast(n: Int): CharSequence Returns a subsequence of this char sequence with the last n characters removed. fun String.dropLast(n: Int): String Returns a string with the last n characters removed. | |
fun CharSequence.dropLastWhile( predicate: (Char) -> Boolean ): CharSequence Returns a subsequence of this char sequence containing all characters except last characters that satisfy the given predicate. fun String.dropLastWhile( predicate: (Char) -> Boolean ): String Returns a string containing all characters except last characters that satisfy the given predicate. | |
fun CharSequence.dropWhile( predicate: (Char) -> Boolean ): CharSequence Returns a subsequence of this char sequence containing all characters except first characters that satisfy the given predicate. fun String.dropWhile(predicate: (Char) -> Boolean): String Returns a string containing all characters except first characters that satisfy the given predicate. | |
fun CharSequence.elementAt(index: Int): Char Returns a character at the given index or throws an IndexOutOfBoundsException if the index is out of bounds of this char sequence. | |
fun CharSequence.elementAtOrElse( index: Int, defaultValue: (Int) -> Char ): Char Returns a character at the given index or the result of calling the defaultValue function if the index is out of bounds of this char sequence. | |
fun CharSequence.elementAtOrNull(index: Int): Char? Returns a character at the given index or | |
fun CharSequence.endsWith( char: Char, ignoreCase: Boolean = false ): Boolean Returns fun CharSequence.endsWith( suffix: CharSequence, ignoreCase: Boolean = false ): Boolean Returns fun String.endsWith( suffix: String, ignoreCase: Boolean = false ): Boolean Returns | |
fun String?.equals( other: String?, ignoreCase: Boolean = false ): Boolean Returns fun Char.equals( other: Char, ignoreCase: Boolean = false ): Boolean Returns | |
fun CharSequence.filter( predicate: (Char) -> Boolean ): CharSequence Returns a char sequence containing only those characters from the original char sequence that match the given predicate. fun String.filter(predicate: (Char) -> Boolean): String Returns a string containing only those characters from the original string that match the given predicate. | |
fun CharSequence.filterIndexed( predicate: (index: Int, Char) -> Boolean ): CharSequence Returns a char sequence containing only those characters from the original char sequence that match the given predicate. fun String.filterIndexed( predicate: (index: Int, Char) -> Boolean ): String Returns a string containing only those characters from the original string that match the given predicate. | |
fun <C : Appendable> CharSequence.filterIndexedTo( destination: C, predicate: (index: Int, Char) -> Boolean ): C Appends all characters matching the given predicate to the given destination. | |
fun CharSequence.filterNot( predicate: (Char) -> Boolean ): CharSequence Returns a char sequence containing only those characters from the original char sequence that do not match the given predicate. fun String.filterNot(predicate: (Char) -> Boolean): String Returns a string containing only those characters from the original string that do not match the given predicate. | |
fun <C : Appendable> CharSequence.filterNotTo( destination: C, predicate: (Char) -> Boolean ): C Appends all characters not matching the given predicate to the given destination. | |
fun <C : Appendable> CharSequence.filterTo( destination: C, predicate: (Char) -> Boolean ): C Appends all characters matching the given predicate to the given destination. | |
fun CharSequence.find(predicate: (Char) -> Boolean): Char? Returns the first character matching the given predicate, or | |
fun CharSequence.findAnyOf( strings: Collection<String>, startIndex: Int = 0, ignoreCase: Boolean = false ): Pair<Int, String>? Finds the first occurrence of any of the specified strings in this char sequence, starting from the specified startIndex and optionally ignoring the case. | |
fun CharSequence.findLast( predicate: (Char) -> Boolean ): Char? Returns the last character matching the given predicate, or | |
fun CharSequence.findLastAnyOf( strings: Collection<String>, startIndex: Int = lastIndex, ignoreCase: Boolean = false ): Pair<Int, String>? Finds the last occurrence of any of the specified strings in this char sequence, starting from the specified startIndex and optionally ignoring the case. | |
fun CharSequence.first(): Char Returns first character. fun CharSequence.first(predicate: (Char) -> Boolean): Char Returns the first character matching the given predicate. | |
fun CharSequence.firstOrNull(): Char? Returns the first character, or fun CharSequence.firstOrNull( predicate: (Char) -> Boolean ): Char? Returns the first character matching the given predicate, or | |
fun <R> CharSequence.flatMap( transform: (Char) -> Iterable<R> ): List<R> Returns a single list of all elements yielded from results of transform function being invoked on each character of original char sequence. | |
fun <R, C : MutableCollection<in R>> CharSequence.flatMapTo( destination: C, transform: (Char) -> Iterable<R> ): C Appends all elements yielded from results of transform function being invoked on each character of original char sequence, to the given destination. | |
fun <R> CharSequence.fold( initial: R, operation: (acc: R, Char) -> R ): R Accumulates value starting with initial value and applying operation from left to right to current accumulator value and each character. | |
fun <R> CharSequence.foldIndexed( initial: R, operation: (index: Int, acc: R, Char) -> R ): R Accumulates value starting with initial value and applying operation from left to right to current accumulator value and each character with its index in the original char sequence. | |
fun <R> CharSequence.foldRight( initial: R, operation: (Char, acc: R) -> R ): R Accumulates value starting with initial value and applying operation from right to left to each character and current accumulator value. | |
fun <R> CharSequence.foldRightIndexed( initial: R, operation: (index: Int, Char, acc: R) -> R ): R Accumulates value starting with initial value and applying operation from right to left to each character with its index in the original char sequence and current accumulator value. | |
fun CharSequence.forEach(action: (Char) -> Unit) Performs the given action on each character. | |
fun CharSequence.forEachIndexed( action: (index: Int, Char) -> Unit) Performs the given action on each character, providing sequential index with the character. | |
fun String.format(vararg args: Any?): String Uses this string as a format string and returns a string obtained by substituting the specified arguments, using the default locale. fun String.format(locale: Locale, vararg args: Any?): String Uses this string as a format string and returns a string obtained by substituting the specified arguments, using the specified locale. | |
operator fun MatchGroupCollection.get( name: String ): MatchGroup? Returns a named group with the specified name. | |
fun CharSequence.getOrElse( index: Int, defaultValue: (Int) -> Char ): Char Returns a character at the given index or the result of calling the defaultValue function if the index is out of bounds of this char sequence. | |
fun CharSequence.getOrNull(index: Int): Char? Returns a character at the given index or | |
fun <K> CharSequence.groupBy( keySelector: (Char) -> K ): Map<K, List<Char>> Groups characters of the original char sequence by the key returned by the given keySelector function applied to each character and returns a map where each group key is associated with a list of corresponding characters. fun <K, V> CharSequence.groupBy( keySelector: (Char) -> K, valueTransform: (Char) -> V ): Map<K, List<V>> Groups values returned by the valueTransform function applied to each character of the original char sequence by the key returned by the given keySelector function applied to the character and returns a map where each group key is associated with a list of corresponding values. | |
fun <K, M : MutableMap<in K, MutableList<Char>>> CharSequence.groupByTo( destination: M, keySelector: (Char) -> K ): M Groups characters of the original char sequence by the key returned by the given keySelector function applied to each character and puts to the destination map each group key associated with a list of corresponding characters. fun <K, V, M : MutableMap<in K, MutableList<V>>> CharSequence.groupByTo( destination: M, keySelector: (Char) -> K, valueTransform: (Char) -> V ): M Groups values returned by the valueTransform function applied to each character of the original char sequence by the key returned by the given keySelector function applied to the character and puts to the destination map each group key associated with a list of corresponding values. | |
fun <K> CharSequence.groupingBy( keySelector: (Char) -> K ): Grouping<Char, K> Creates a Grouping source from a char sequence to be used later with one of group-and-fold operations using the specified keySelector function to extract a key from each character. | |
fun CharSequence.hasSurrogatePairAt(index: Int): Boolean Returns | |
fun CharSequence.indexOf( char: Char, startIndex: Int = 0, ignoreCase: Boolean = false ): Int Returns the index within this string of the first occurrence of the specified character, starting from the specified startIndex. fun CharSequence.indexOf( string: String, startIndex: Int = 0, ignoreCase: Boolean = false ): Int Returns the index within this char sequence of the first occurrence of the specified string, starting from the specified startIndex. | |
fun CharSequence.indexOfAny( chars: CharArray, startIndex: Int = 0, ignoreCase: Boolean = false ): Int Finds the index of the first occurrence of any of the specified chars in this char sequence, starting from the specified startIndex and optionally ignoring the case. fun CharSequence.indexOfAny( strings: Collection<String>, startIndex: Int = 0, ignoreCase: Boolean = false ): Int Finds the index of the first occurrence of any of the specified strings in this char sequence, starting from the specified startIndex and optionally ignoring the case. | |
fun CharSequence.indexOfFirst( predicate: (Char) -> Boolean ): Int Returns index of the first character matching the given predicate, or -1 if the char sequence does not contain such character. | |
fun CharSequence.indexOfLast( predicate: (Char) -> Boolean ): Int Returns index of the last character matching the given predicate, or -1 if the char sequence does not contain such character. | |
fun String.intern(): String Returns a canonical representation for this string object. | |
fun CharSequence.isBlank(): Boolean Returns | |
fun Char.isDefined(): Boolean Returns | |
fun Char.isDigit(): Boolean Returns | |
fun CharSequence.isEmpty(): Boolean Returns | |
fun Char.isHighSurrogate(): Boolean Returns | |
fun Char.isISOControl(): Boolean Returns | |
fun Char.isIdentifierIgnorable(): Boolean Returns | |
fun Char.isJavaIdentifierPart(): Boolean Returns | |
fun Char.isJavaIdentifierStart(): Boolean Returns | |
fun Char.isLetter(): Boolean Returns | |
fun Char.isLetterOrDigit(): Boolean Returns | |
fun Char.isLowSurrogate(): Boolean Returns | |
fun Char.isLowerCase(): Boolean Returns | |
fun CharSequence.isNotBlank(): Boolean Returns | |
fun CharSequence.isNotEmpty(): Boolean Returns | |
fun CharSequence?.isNullOrBlank(): Boolean Returns | |
fun CharSequence?.isNullOrEmpty(): Boolean Returns | |
fun Char.isSurrogate(): Boolean Returns | |
fun Char.isTitleCase(): Boolean Returns | |
fun Char.isUpperCase(): Boolean Returns | |
fun Char.isWhitespace(): Boolean Determines whether a character is whitespace according to the Unicode standard. Returns | |
operator fun CharSequence.iterator(): CharIterator Iterator for characters of the given char sequence. | |
fun CharSequence.last(): Char Returns the last character. fun CharSequence.last(predicate: (Char) -> Boolean): Char Returns the last character matching the given predicate. | |
fun CharSequence.lastIndexOf( char: Char, startIndex: Int = lastIndex, ignoreCase: Boolean = false ): Int Returns the index within this char sequence of the last occurrence of the specified character, starting from the specified startIndex. fun CharSequence.lastIndexOf( string: String, startIndex: Int = lastIndex, ignoreCase: Boolean = false ): Int Returns the index within this char sequence of the last occurrence of the specified string, starting from the specified startIndex. | |
fun CharSequence.lastIndexOfAny( chars: CharArray, startIndex: Int = lastIndex, ignoreCase: Boolean = false ): Int Finds the index of the last occurrence of any of the specified chars in this char sequence, starting from the specified startIndex and optionally ignoring the case. fun CharSequence.lastIndexOfAny( strings: Collection<String>, startIndex: Int = lastIndex, ignoreCase: Boolean = false ): Int Finds the index of the last occurrence of any of the specified strings in this char sequence, starting from the specified startIndex and optionally ignoring the case. | |
fun CharSequence.lastOrNull(): Char? Returns the last character, or fun CharSequence.lastOrNull( predicate: (Char) -> Boolean ): Char? Returns the last character matching the given predicate, or | |
fun CharSequence.lineSequence(): Sequence<String> Splits this char sequence to a sequence of lines delimited by any of the following character sequences: CRLF, LF or CR. | |
fun CharSequence.lines(): List<String>
| |
fun <R> CharSequence.map(transform: (Char) -> R): List<R> Returns a list containing the results of applying the given transform function to each character in the original char sequence. | |
fun <R> CharSequence.mapIndexed( transform: (index: Int, Char) -> R ): List<R> Returns a list containing the results of applying the given transform function to each character and its index in the original char sequence. | |
fun <R : Any> CharSequence.mapIndexedNotNull( transform: (index: Int, Char) -> R? ): List<R> Returns a list containing only the non-null results of applying the given transform function to each character and its index in the original char sequence. | |
fun <R : Any, C : MutableCollection<in R>> CharSequence.mapIndexedNotNullTo( destination: C, transform: (index: Int, Char) -> R? ): C Applies the given transform function to each character and its index in the original char sequence and appends only the non-null results to the given destination. | |
fun <R, C : MutableCollection<in R>> CharSequence.mapIndexedTo( destination: C, transform: (index: Int, Char) -> R ): C Applies the given transform function to each character and its index in the original char sequence and appends the results to the given destination. | |
fun <R : Any> CharSequence.mapNotNull( transform: (Char) -> R? ): List<R> Returns a list containing only the non-null results of applying the given transform function to each character in the original char sequence. | |
fun <R : Any, C : MutableCollection<in R>> CharSequence.mapNotNullTo( destination: C, transform: (Char) -> R? ): C Applies the given transform function to each character in the original char sequence and appends only the non-null results to the given destination. | |
fun <R, C : MutableCollection<in R>> CharSequence.mapTo( destination: C, transform: (Char) -> R ): C Applies the given transform function to each character of the original char sequence and appends the results to the given destination. | |
fun String.match(regex: String): Array<String> | |
infix fun CharSequence.matches(regex: Regex): Boolean Returns fun String.matches(regex: String): Boolean | |
fun CharSequence.max(): Char? Returns the largest character or | |
fun <R : Comparable<R>> CharSequence.maxBy( selector: (Char) -> R ): Char? Returns the first character yielding the largest value of the given function or | |
fun CharSequence.maxWith( comparator: Comparator<in Char> ): Char? fun CharSequence.maxWith( comparator: Comparator<in Char> ): Char? Returns the first character having the largest value according to the provided comparator or | |
fun CharSequence.min(): Char? Returns the smallest character or | |
fun <R : Comparable<R>> CharSequence.minBy( selector: (Char) -> R ): Char? Returns the first character yielding the smallest value of the given function or | |
fun CharSequence.minWith( comparator: Comparator<in Char> ): Char? fun CharSequence.minWith( comparator: Comparator<in Char> ): Char? Returns the first character having the smallest value according to the provided comparator or | |
fun CharSequence.none(): Boolean Returns fun CharSequence.none(predicate: (Char) -> Boolean): Boolean Returns | |
fun String.offsetByCodePoints( index: Int, codePointOffset: Int ): Int Returns the index within this string that is offset from the given index by codePointOffset code points. | |
fun <S : CharSequence> S.onEach(action: (Char) -> Unit): S Performs the given action on each character and returns the char sequence itself afterwards. | |
fun String?.orEmpty(): String Returns the string if it is not | |
fun CharSequence.padEnd( length: Int, padChar: Char = ' ' ): CharSequence Returns a char sequence with content of this char sequence padded at the end to the specified length with the specified character or space. fun String.padEnd(length: Int, padChar: Char = ' '): String Pads the string to the specified length at the end with the specified character or space. | |
fun CharSequence.padStart( length: Int, padChar: Char = ' ' ): CharSequence Returns a char sequence with content of this char sequence padded at the beginning to the specified length with the specified character or space. fun String.padStart(length: Int, padChar: Char = ' '): String Pads the string to the specified length at the beginning with the specified character or space. | |
fun CharSequence.partition( predicate: (Char) -> Boolean ): Pair<CharSequence, CharSequence> Splits the original char sequence into pair of char sequences, where first char sequence contains characters for which predicate yielded fun String.partition( predicate: (Char) -> Boolean ): Pair<String, String> Splits the original string into pair of strings, where first string contains characters for which predicate yielded | |
operator fun Char.plus(other: String): String Concatenates this Char and a String. | |
fun String.prependIndent(indent: String = " "): String Prepends indent to every line of the original string. | |
fun CharSequence.reduce( operation: (acc: Char, Char) -> Char ): Char Accumulates value starting with the first character and applying operation from left to right to current accumulator value and each character. | |
fun CharSequence.reduceIndexed( operation: (index: Int, acc: Char, Char) -> Char ): Char Accumulates value starting with the first character and applying operation from left to right to current accumulator value and each character with its index in the original char sequence. | |
fun CharSequence.reduceRight( operation: (Char, acc: Char) -> Char ): Char Accumulates value starting with last character and applying operation from right to left to each character and current accumulator value. | |
fun CharSequence.reduceRightIndexed( operation: (index: Int, Char, acc: Char) -> Char ): Char Accumulates value starting with last character and applying operation from right to left to each character with its index in the original char sequence and current accumulator value. | |
fun CharSequence.regionMatches( thisOffset: Int, other: CharSequence, otherOffset: Int, length: Int, ignoreCase: Boolean = false ): Boolean Returns fun String.regionMatches( thisOffset: Int, other: String, otherOffset: Int, length: Int, ignoreCase: Boolean = false ): Boolean Returns | |
fun CharSequence.removePrefix( prefix: CharSequence ): CharSequence If this char sequence starts with the given prefix, returns a new char sequence with the prefix removed. Otherwise, returns a new char sequence with the same characters. fun String.removePrefix(prefix: CharSequence): String If this string starts with the given prefix, returns a copy of this string with the prefix removed. Otherwise, returns this string. | |
fun CharSequence.removeRange( startIndex: Int, endIndex: Int ): CharSequence Returns a char sequence with content of this char sequence where its part at the given range is removed. fun String.removeRange( startIndex: Int, endIndex: Int ): String Removes the part of a string at a given range. fun CharSequence.removeRange(range: IntRange): CharSequence Returns a char sequence with content of this char sequence where its part at the given range is removed. fun String.removeRange(range: IntRange): String Removes the part of a string at the given range. | |
fun CharSequence.removeSuffix( suffix: CharSequence ): CharSequence If this char sequence ends with the given suffix, returns a new char sequence with the suffix removed. Otherwise, returns a new char sequence with the same characters. fun String.removeSuffix(suffix: CharSequence): String If this string ends with the given suffix, returns a copy of this string with the suffix removed. Otherwise, returns this string. | |
fun CharSequence.removeSurrounding( prefix: CharSequence, suffix: CharSequence ): CharSequence When this char sequence starts with the given prefix and ends with the given suffix, returns a new char sequence having both the given prefix and suffix removed. Otherwise returns a new char sequence with the same characters. fun String.removeSurrounding( prefix: CharSequence, suffix: CharSequence ): String Removes from a string both the given prefix and suffix if and only if it starts with the prefix and ends with the suffix. Otherwise returns this string unchanged. fun CharSequence.removeSurrounding( delimiter: CharSequence ): CharSequence When this char sequence starts with and ends with the given delimiter, returns a new char sequence having this delimiter removed both from the start and end. Otherwise returns a new char sequence with the same characters. fun String.removeSurrounding(delimiter: CharSequence): String Removes the given delimiter string from both the start and the end of this string if and only if it starts with and ends with the delimiter. Otherwise returns this string unchanged. | |
fun CharSequence.repeat(n: Int): String Returns a string containing this char sequence repeated n times. | |
fun CharSequence.replace( regex: Regex, replacement: String ): String Returns a new string obtained by replacing each substring of this char sequence that matches the given regular expression with the given replacement. fun CharSequence.replace( regex: Regex, transform: (MatchResult) -> CharSequence ): String Returns a new string obtained by replacing each substring of this char sequence that matches the given regular expression with the result of the given function transform that takes MatchResult and returns a string to be used as a replacement for that match. fun String.replace( oldChar: Char, newChar: Char, ignoreCase: Boolean = false ): String Returns a new string with all occurrences of oldChar replaced with newChar. fun String.replace( oldValue: String, newValue: String, ignoreCase: Boolean = false ): String Returns a new string obtained by replacing all occurrences of the oldValue substring in this string with the specified newValue string. | |
fun String.replaceAfter( delimiter: Char, replacement: String, missingDelimiterValue: String = this ): String fun String.replaceAfter( delimiter: String, replacement: String, missingDelimiterValue: String = this ): String Replace part of string after the first occurrence of given delimiter with the replacement string. If the string does not contain the delimiter, returns missingDelimiterValue which defaults to the original string. | |
fun String.replaceAfterLast( delimiter: String, replacement: String, missingDelimiterValue: String = this ): String fun String.replaceAfterLast( delimiter: Char, replacement: String, missingDelimiterValue: String = this ): String Replace part of string after the last occurrence of given delimiter with the replacement string. If the string does not contain the delimiter, returns missingDelimiterValue which defaults to the original string. | |
fun String.replaceBefore( delimiter: Char, replacement: String, missingDelimiterValue: String = this ): String fun String.replaceBefore( delimiter: String, replacement: String, missingDelimiterValue: String = this ): String Replace part of string before the first occurrence of given delimiter with the replacement string. If the string does not contain the delimiter, returns missingDelimiterValue which defaults to the original string. | |
fun String.replaceBeforeLast( delimiter: Char, replacement: String, missingDelimiterValue: String = this ): String fun String.replaceBeforeLast( delimiter: String, replacement: String, missingDelimiterValue: String = this ): String Replace part of string before the last occurrence of given delimiter with the replacement string. If the string does not contain the delimiter, returns missingDelimiterValue which defaults to the original string. | |
fun CharSequence.replaceFirst( regex: Regex, replacement: String ): String Replaces the first occurrence of the given regular expression regex in this char sequence with specified replacement expression. fun String.replaceFirst( oldChar: Char, newChar: Char, ignoreCase: Boolean = false ): String Returns a new string with the first occurrence of oldChar replaced with newChar. fun String.replaceFirst( oldValue: String, newValue: String, ignoreCase: Boolean = false ): String Returns a new string obtained by replacing the first occurrence of the oldValue substring in this string with the specified newValue string. | |
fun String.replaceIndent(newIndent: String = ""): String Detects a common minimal indent like it does trimIndent and replaces it with the specified newIndent. | |
fun String.replaceIndentByMargin( newIndent: String = "", marginPrefix: String = "|" ): String Detects indent by marginPrefix as it does trimMargin and replace it with newIndent. | |
fun CharSequence.replaceRange( startIndex: Int, endIndex: Int, replacement: CharSequence ): CharSequence Returns a char sequence with content of this char sequence where its part at the given range is replaced with the replacement char sequence. fun String.replaceRange( startIndex: Int, endIndex: Int, replacement: CharSequence ): String Replaces the part of the string at the given range with the replacement char sequence. fun CharSequence.replaceRange( range: IntRange, replacement: CharSequence ): CharSequence Returns a char sequence with content of this char sequence where its part at the given range is replaced with the replacement char sequence. fun String.replaceRange( range: IntRange, replacement: CharSequence ): String Replace the part of string at the given range with the replacement string. | |
fun CharSequence.reversed(): CharSequence Returns a char sequence with characters in reversed order. fun String.reversed(): String Returns a string with characters in reversed order. | |
fun CharSequence.single(): Char Returns the single character, or throws an exception if the char sequence is empty or has more than one character. fun CharSequence.single(predicate: (Char) -> Boolean): Char Returns the single character matching the given predicate, or throws exception if there is no or more than one matching character. | |
fun CharSequence.singleOrNull(): Char? Returns single character, or fun CharSequence.singleOrNull( predicate: (Char) -> Boolean ): Char? Returns the single character matching the given predicate, or | |
fun CharSequence.slice(indices: IntRange): CharSequence Returns a char sequence containing characters of the original char sequence at the specified range of indices. fun String.slice(indices: IntRange): String Returns a string containing characters of the original string at the specified range of indices. fun CharSequence.slice(indices: Iterable<Int>): CharSequence Returns a char sequence containing characters of the original char sequence at specified indices. fun String.slice(indices: Iterable<Int>): String Returns a string containing characters of the original string at specified indices. | |
fun CharSequence.split( vararg delimiters: String, ignoreCase: Boolean = false, limit: Int = 0 ): List<String> fun CharSequence.split( vararg delimiters: Char, ignoreCase: Boolean = false, limit: Int = 0 ): List<String> Splits this char sequence to a list of strings around occurrences of the specified delimiters. fun CharSequence.split( regex: Regex, limit: Int = 0 ): List<String> fun CharSequence.split( regex: Pattern, limit: Int = 0 ): List<String> Splits this char sequence around matches of the given regular expression. | |
fun CharSequence.splitToSequence( vararg delimiters: String, ignoreCase: Boolean = false, limit: Int = 0 ): Sequence<String> fun CharSequence.splitToSequence( vararg delimiters: Char, ignoreCase: Boolean = false, limit: Int = 0 ): Sequence<String> Splits this char sequence to a sequence of strings around occurrences of the specified delimiters. | |
fun CharSequence.startsWith( char: Char, ignoreCase: Boolean = false ): Boolean Returns fun CharSequence.startsWith( prefix: CharSequence, ignoreCase: Boolean = false ): Boolean Returns fun CharSequence.startsWith( prefix: CharSequence, startIndex: Int, ignoreCase: Boolean = false ): Boolean Returns fun String.startsWith( prefix: String, ignoreCase: Boolean = false ): Boolean Returns fun String.startsWith( prefix: String, startIndex: Int, ignoreCase: Boolean = false ): Boolean Returns | |
fun CharSequence.subSequence(range: IntRange): CharSequence Returns a subsequence of this char sequence specified by the given range of indices. | |
fun String.substring(range: IntRange): String Returns a substring specified by the given range of indices. fun CharSequence.substring( startIndex: Int, endIndex: Int = length ): String Returns a substring of chars from a range of this char sequence starting at the startIndex and ending right before the endIndex. fun CharSequence.substring(range: IntRange): String Returns a substring of chars at indices from the specified range of this char sequence. fun String.substring(startIndex: Int): String Returns a substring of this string that starts at the specified startIndex and continues to the end of the string. fun String.substring(startIndex: Int, endIndex: Int): String Returns the substring of this string starting at the startIndex and ending right before the endIndex. | |
fun String.substringAfter( delimiter: Char, missingDelimiterValue: String = this ): String fun String.substringAfter( delimiter: String, missingDelimiterValue: String = this ): String Returns a substring after the first occurrence of delimiter. If the string does not contain the delimiter, returns missingDelimiterValue which defaults to the original string. | |
fun String.substringAfterLast( delimiter: Char, missingDelimiterValue: String = this ): String fun String.substringAfterLast( delimiter: String, missingDelimiterValue: String = this ): String Returns a substring after the last occurrence of delimiter. If the string does not contain the delimiter, returns missingDelimiterValue which defaults to the original string. | |
fun String.substringBefore( delimiter: Char, missingDelimiterValue: String = this ): String fun String.substringBefore( delimiter: String, missingDelimiterValue: String = this ): String Returns a substring before the first occurrence of delimiter. If the string does not contain the delimiter, returns missingDelimiterValue which defaults to the original string. | |
fun String.substringBeforeLast( delimiter: Char, missingDelimiterValue: String = this ): String fun String.substringBeforeLast( delimiter: String, missingDelimiterValue: String = this ): String Returns a substring before the last occurrence of delimiter. If the string does not contain the delimiter, returns missingDelimiterValue which defaults to the original string. | |
fun CharSequence.sumBy(selector: (Char) -> Int): Int Returns the sum of all values produced by selector function applied to each character in the char sequence. | |
fun CharSequence.sumByDouble( selector: (Char) -> Double ): Double Returns the sum of all values produced by selector function applied to each character in the char sequence. | |
fun CharSequence.take(n: Int): CharSequence Returns a subsequence of this char sequence containing the first n characters from this char sequence, or the entire char sequence if this char sequence is shorter. fun String.take(n: Int): String Returns a string containing the first n characters from this string, or the entire string if this string is shorter. | |
fun CharSequence.takeLast(n: Int): CharSequence Returns a subsequence of this char sequence containing the last n characters from this char sequence, or the entire char sequence if this char sequence is shorter. fun String.takeLast(n: Int): String Returns a string containing the last n characters from this string, or the entire string if this string is shorter. | |
fun CharSequence.takeLastWhile( predicate: (Char) -> Boolean ): CharSequence Returns a subsequence of this char sequence containing last characters that satisfy the given predicate. fun String.takeLastWhile( predicate: (Char) -> Boolean ): String Returns a string containing last characters that satisfy the given predicate. | |
fun CharSequence.takeWhile( predicate: (Char) -> Boolean ): CharSequence Returns a subsequence of this char sequence containing the first characters that satisfy the given predicate. fun String.takeWhile(predicate: (Char) -> Boolean): String Returns a string containing the first characters that satisfy the given predicate. | |
fun String.toBoolean(): Boolean Returns | |
fun String.toByte(): Byte fun String.toByte(radix: Int): Byte Parses the string as a signed Byte number and returns the result. | |
fun String.toByteArray( charset: Charset = Charsets.UTF_8 ): ByteArray Encodes the contents of this string using the specified character set and returns the resulting byte array. | |
fun String.toByteOrNull(): Byte? fun String.toByteOrNull(radix: Int): Byte? Parses the string as a signed Byte number and returns the result or | |
fun String.toCharArray(): CharArray Returns a new character array containing the characters from this string. fun String.toCharArray( destination: CharArray, destinationOffset: Int = 0, startIndex: Int = 0, endIndex: Int = length ): CharArray Copies characters from this string into the destination character array and returns that array. | |
fun <C : MutableCollection<in Char>> CharSequence.toCollection( destination: C ): C Appends all characters to the given destination collection. | |
fun String.toDouble(): Double Parses the string as a Double number and returns the result. | |
fun String.toDoubleOrNull(): Double? Parses the string as a Double number and returns the result or | |
fun String.toFloat(): Float Parses the string as a Float number and returns the result. | |
fun String.toFloatOrNull(): Float? Parses the string as a Float number and returns the result or | |
fun CharSequence.toHashSet(): HashSet<Char> Returns a HashSet of all characters. | |
fun String.toInt(): Int fun String.toInt(radix: Int): Int Parses the string as an Int number and returns the result. | |
fun String.toIntOrNull(): Int? fun String.toIntOrNull(radix: Int): Int? Parses the string as an Int number and returns the result or | |
fun CharSequence.toList(): List<Char> Returns a List containing all characters. | |
fun String.toLong(): Long fun String.toLong(radix: Int): Long Parses the string as a Long number and returns the result. | |
fun String.toLongOrNull(): Long? fun String.toLongOrNull(radix: Int): Long? Parses the string as a Long number and returns the result or | |
fun Char.toLowerCase(): Char Converts this character to lowercase. fun String.toLowerCase(): String Returns a copy of this string converted to lower case using the rules of the default locale. fun String.toLowerCase(locale: Locale): String Returns a copy of this string converted to lower case using the rules of the specified locale. | |
fun CharSequence.toMutableList(): MutableList<Char> Returns a MutableList filled with all characters of this char sequence. | |
fun String.toPattern(flags: Int = 0): Pattern Converts the string into a regular expression Pattern optionally with the specified flags from Pattern or'd together so that strings can be split or matched on. | |
fun String.toRegex(): Regex Converts the string into a regular expression Regex with the default options. fun String.toRegex(option: RegexOption): Regex Converts the string into a regular expression Regex with the specified single option. fun String.toRegex(options: Set<RegexOption>): Regex Converts the string into a regular expression Regex with the specified set of options. | |
fun CharSequence.toSet(): Set<Char> Returns a Set of all characters. | |
fun String.toShort(): Short fun String.toShort(radix: Int): Short Parses the string as a Short number and returns the result. | |
fun String.toShortOrNull(): Short? fun String.toShortOrNull(radix: Int): Short? Parses the string as a Short number and returns the result or | |
fun CharSequence.toSortedSet(): SortedSet<Char> Returns a SortedSet of all characters. | |
fun Byte.toString(radix: Int): String Returns a string representation of this Byte value in the specified radix. fun Short.toString(radix: Int): String Returns a string representation of this Short value in the specified radix. fun Int.toString(radix: Int): String Returns a string representation of this Int value in the specified radix. fun Long.toString(radix: Int): String Returns a string representation of this Long value in the specified radix. | |
fun Char.toTitleCase(): Char Converts this character to titlecase. | |
fun Char.toUpperCase(): Char Converts this character to uppercase. fun String.toUpperCase(): String Returns a copy of this string converted to upper case using the rules of the default locale. fun String.toUpperCase(locale: Locale): String Returns a copy of this string converted to upper case using the rules of the specified locale. | |
fun CharSequence.trim( predicate: (Char) -> Boolean ): CharSequence Returns a sub sequence of this char sequence having leading and trailing characters matching the predicate trimmed. fun String.trim(predicate: (Char) -> Boolean): String Returns a string with leading and trailing characters matching the predicate trimmed. fun CharSequence.trim(vararg chars: Char): CharSequence Returns a sub sequence of this char sequence having leading and trailing characters from the chars array trimmed. fun String.trim(vararg chars: Char): String Returns a string with leading and trailing characters from the chars array trimmed. fun CharSequence.trim(): CharSequence Returns a sub sequence of this char sequence having leading and trailing whitespace trimmed. fun String.trim(): String Returns a string with leading and trailing whitespace trimmed. | |
fun CharSequence.trimEnd( predicate: (Char) -> Boolean ): CharSequence Returns a sub sequence of this char sequence having trailing characters matching the predicate trimmed. fun String.trimEnd(predicate: (Char) -> Boolean): String Returns a string with trailing characters matching the predicate trimmed. fun CharSequence.trimEnd(vararg chars: Char): CharSequence Returns a sub sequence of this char sequence having trailing characters from the chars array trimmed. fun String.trimEnd(vararg chars: Char): String Returns a string with trailing characters from the chars array trimmed. fun CharSequence.trimEnd(): CharSequence Returns a sub sequence of this char sequence having trailing whitespace removed. fun String.trimEnd(): String Returns a string with trailing whitespace removed. | |
fun String.trimIndent(): String Detects a common minimal indent of all the input lines, removes it from every line and also removes first and last lines if they are blank (notice difference blank vs empty). | |
fun String.trimMargin(marginPrefix: String = "|"): String Trims leading whitespace characters followed by marginPrefix from every line of a source string and removes first and last lines if they are blank (notice difference blank vs empty). | |
fun CharSequence.trimStart( predicate: (Char) -> Boolean ): CharSequence Returns a sub sequence of this char sequence having leading characters matching the predicate trimmed. fun String.trimStart(predicate: (Char) -> Boolean): String Returns a string with leading characters matching the predicate trimmed. fun CharSequence.trimStart(vararg chars: Char): CharSequence Returns a sub sequence of this char sequence having leading and trailing characters from the chars array trimmed. fun String.trimStart(vararg chars: Char): String Returns a string with leading and trailing characters from the chars array trimmed. fun CharSequence.trimStart(): CharSequence Returns a sub sequence of this char sequence having leading whitespace removed. fun String.trimStart(): String Returns a string with leading whitespace removed. | |
fun CharSequence.withIndex(): Iterable<IndexedValue<Char>> Returns a lazy Iterable of IndexedValue for each character of the original char sequence. | |
infix fun CharSequence.zip( other: CharSequence ): List<Pair<Char, Char>> Returns a list of pairs built from characters of both char sequences with same indexes. List has length of shortest char sequence. fun <V> CharSequence.zip( other: CharSequence, transform: (a: Char, b: Char) -> V ): List<V> Returns a list of values built from characters of both char sequences with same indexes using provided transform. List has length of shortest char sequence. |
Companion Object Properties
val String.Companion.CASE_INSENSITIVE_ORDER: Comparator<String> A Comparator that orders strings ignoring character case. |
Companion Object Functions
fun String.Companion.format( format: String, vararg args: Any? ): String fun String.Companion.format( locale: Locale, format: String, vararg args: Any? ): String Uses this string as a format string and returns a string obtained by substituting the specified arguments, using the default locale. |
© 2010–2017 JetBrains s.r.o.
Licensed under the Apache License, Version 2.0.
https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.text/