This string.

Determines if this string has no characters, that is, if it has zero size. This is a much more efficient operation than string.size==0.

The first character in the string.

A hash code for this String, computed from its UTF-16 code units.

A sequence containing all indexes of this string.

The last character in the string.

The index of the last character in the string, or null if the string has no characters. Note that this operation is potentially costly for long strings, since the underlying representation of the characters uses a UTF-16 encoding. For any nonempty string:

string.lastIndex == string.size-1

Split the string into lines of text, discarding line breaks. Recognized line break sequences are \n and \r\n. The empty string is considered a single line of text.

Split the string into lines of text with line breaks. Each line will be terminated by a line break sequence, \n or \r\n, except for the very last line. The empty string is considered a single line of text.

This string, with all characters in lowercase.

Conversion of uppercase characters to lowercase is performed according to a locale-independent mapping that produces incorrect results in certain locales (e.g. tr-TR).

The resulting string may not have the same number of characters as this string, since the uppercase representation of certain characters comprises multiple characters, for example the lowercase representation of İ is two characters wide.

A string containing the characters of this string after collapsing strings of adjacent whitespace characters into single space characters and discarding whitespace from the beginning and end of the string.

The rest of the string, without its first character.

A string containing the characters of this string, with the characters in reverse order.

The length of the string (the number of characters it contains). In the case of the empty string, the string has length zero. Note that this operation is potentially costly for long strings, since the underlying representation of the characters uses a UTF-16 encoding. Use of longerThan() or shorterThan() is highly recommended.

This string.

A string containing the characters of this string, after discarding whitespace from the beginning and end of the string.

This string, with all characters in uppercase.

Conversion of lowercase characters to uppercase is performed according to a locale-independent mapping that produces incorrect results in certain locales (e.g. tr-TR).

The resulting string may not have the same number of characters as this string, since the uppercase representation of certain characters comprises multiple characters, for example the uppercase representation of ß is SS.

Determine if this string contains only whitespace characters. Returns false if the string contains at least one character which is not a whitespace character.

Determines if there is at least one element of this stream that satisfies the given predicate function. If the stream is empty, returns false. For an infinite stream, this operation might not terminate.

This string.

Compare this string with the given string lexicographically, according to the Unicode code points of the characters.

This defines a locale-independent collation that is incorrect in some locales.

For more specialized lexicographic comparisons between strings, use compareIgnoringCase() or compareCorresponding().

Compare this string with the given string lexicographically, ignoring the case of the characters. That is, by considering two characters x and y as equal if:

• x == y,
• x.uppercased == y.uppercased, or
• x.lowercased == y.lowercased.

This defines a locale-independent collation that is incorrect in some locales.

For more specialized lexicographic comparisons between strings, use compareCorresponding().

Determines if the given object is a String and, if so, if it occurs as a substring of this string, or if the object is a Character that occurs in this string. That is to say, a string is considered a Category of its substrings and of its characters.

Using the in operator (Category.contains), string.contains(element) may be written as element in string.

Efficiently copy the characters in the segment sourcePosition:length of this string to the segment destinationPosition:length of the given character array.

The given sourcePosition and destinationPosition must be non-negative and, together with the given length, must identify meaningful ranges within the two lists, satisfying:

• size >= sourcePosition+length, and
• destination.size >= destinationPosition+length.

If the given length is not strictly positive, no elements are copied.

Produces the number of elements in this stream that satisfy the given predicate function. For an infinite stream, this method never terminates.

Determines if this string contains a character at the given index, that is, if 0<=index<size.

Call the given function for each element of this stream, passing the elements in the order they occur in this stream.

For example:

words.each((word) {
    print(word.lowercased);
    print(word.uppercased);
});

Has the same effect as the following for loop:

for (word in words) {
    print(word.lowercased);
    print(word.uppercased);
}

For certain streams this method is highly efficient, surpassing the performance of for loops on the JVM. Thus, each() is sometimes preferred in highly performance-critical low-level code.

Determines if this string ends with the characters of the given string or list. Returns false if the given list contains an element that is not a Character.

Determines if the given object is a String, and if so, if this string has the same length, and the same characters, in the same order, as the given string.

For more specialized character-wise comparisons between strings, use equalsIgnoringCase() or corresponding().

Compare this string with the given string, ignoring the case of the characters. That is, by considering two characters x and y as equal if:

• x == y,
• x.uppercased == y.uppercased, or
• x.lowercased == y.lowercased.

For more specialized character-wise comparisons between strings, use corresponding().

Determines if all elements of this stream satisfy the given predicate function. If the stream is empty, return true. For an infinite stream, this operation might not terminate.

The first element of this stream which is not null and satisfies the given predicate function, if any, or null if there is no such element. For an infinite stream, this method might not terminate.

For example, the expression

(-10..10).find(Integer.positive)

evaluates to 1.

The last element of this stream which is not null and satisfies the given predicate function, if any, or null if there is no such element. For an infinite stream, this method will not terminate.

For example, the expression

(-10..10).findLast(3.divides)

evaluates to 9.

The first index in this list at which the given list occurs as a sublist, that is greater than or equal to the optional starting index.

The first index in this list for which the element is not null and satisfies the given predicate function.

The first index in this list at which the given value occurs, that falls within the segment from:length defined by the optional starting index and length.

Returns the character at the given index in the string, or null if the index is before the start of the string or past the end of string. The first character in the string occurs at index zero. The last character in the string occurs at index string.size-1.

Using the item operator, string.getFromFirst(index) may be written as string[index].

Get the character at the specified index, where the string is indexed from the end of the string, or null if the index falls outside the bounds of this string.

Determine if the given list occurs as a sublist at some index in this list, at any index that is greater than or equal to the optional starting index.

Determine if the given list occurs as a sublist at the given index of this list.

The indexes in this list at which the given list occurs as a sublist, that are greater than or equal to the optional starting index.

The first index greater than or equal to the given start index at which the given substring occurs in this string, if any, or -1 otherwise.

For any string and substring, and for every index from:

string.indexOf(substring, from) 
   == string.firstInclusion(substring, from) 
           else -1

Note: this operation is provided to ease migration of code written in other languages. It is more idiomatic to use firstInclusion() where reasonable.

The indexes in this list for which the element is not null and satisfies the given predicate function.

Select the first characters of this string, returning a string no longer than the given length. If this string is shorter than the given length, return this string. Otherwise, return a string of the given length.

An iterator for the characters of the string.

Join the string representations of the given objects, using this string as a separator.

Determines if this string occurs after the given string in lexicographic order, returning false if the two strings are equal.

The last index in this list at which the given list occurs as a sublist, that falls within the range 0:size-from+1-sublist.size defined by the optional starting index, interpreted as a reverse index counting from the end of the list.

The last index smaller than or equal to the given end index at which the given substring occurs in this string, if any, or -1 otherwise.

For any string and substring, and for every index from:

string.lastIndexOf(substring, from) 
   == string.lastInclusion(substring, string.size-from) 
           else -1

Note: this operation is provided to ease migration of code written in other languages. It is more idiomatic to use lastInclusion() where reasonable.

The last index in this list for which the element is not null and satisfies the given predicate function.

The last index in this list at which the given value occurs, that falls within the range size-length-from:length defined by the optional starting index, interpreted as a reverse index counting from the end of the list, and length.

The first element of this stream which is not null and satisfies the given predicate function, if any, together with its position in the stream, or null if there is no such element. For an infinite stream, this method might not terminate.

For example, the expression

(-10..10).locate(Integer.positive)

evaluates to 11->1.

The last element of this stream which is not null and satisfies the given predicate function, if any, together with its position in the stream, or null if there is no such element. For an infinite stream, this method might not terminate.

For example, the expression

(-10..10).locateLast(3.divides)

evaluates to 19->9.

A stream producing all elements of this stream which are not null and which satisfy the given predicate function, together with their positions in the stream.

For example, the expression

(-5..5).locations(3.divides)

evaluates to the stream { 2->-3, 5->0, 8->3 }.

Note that this method is more efficient than the alternative of applying Iterable.filter() to an Iterable.indexed stream.

Determines if this string is longer than the given length. This is a more efficient operation than string.size>length, since it does not require complete iteration of the underlying UTF-16-encoded native string.

A string containing the characters of this string beginning at the given start index, returning a string no longer than the given length. If the portion of this string starting at the given index is shorter than the given length, return the portion of this string from the given index until the end of this string. Otherwise, return a string of the given length. If the start index is larger than the last index of the string, return the empty string.

Using the measure operator, string.measure(from, length) may be written as string[from:length].

Determines if this string occurs before the given string in lexicographic order, returning true if the two strings are equal.

Determines if this string occurs after the given string in lexicographic order, returning true if the two strings are equal.

The indexes in this list at which the given value occurs.

Determines if the given value occurs as an element of this list, at any index that falls within the segment from:length defined by the optional starting index and length.

Determines if the given value occurs at the given index in this list.

Pad this string with the given character, producing a string of the given minimum size, centering the string. If this string is not smaller than the given size, return this string.

Left pad this string with the given character, producing a string of the given minimum size. If this string is not smaller than the given size, return this string.

Right pad this string with the given character, producing a string of the given minimum size. If this string is not smaller than the given size, return this string.

Returns the concatenation of this string with the given string. The resulting string contains the characters of this string followed by the characters of the given string.

Using the addition operator, string.plus(otherString) may be written as string + otherString.

Beginning with the Iterable.first element of this stream, apply the given combining function to each element of this stream in turn, progressively accumulating a single result.

For an empty stream, reduce() always returns null.

For a stream with one element, reduce() returns that element:

{ first }.reduce(f) == first

For a given stream it with more than one element, and combining function f, the result of reduce() is obtained according to the following recursive definition:

it.reduce(f) == f(it.exceptLast.reduce(f), it.last)

For example, the expression

(1..100).reduce(plus)

results in the integer 5050.

Returns a string formed by removing the given prefix from the start of this string, if this string starts with the given prefix, or this string otherwise.

Returns a string formed by removing the given postfix from the end of this string, if this string ends with the given postfix, or this string otherwise.

Returns a string formed by repeating this string the given number of times, or the empty string if times<=0.

Returns a string formed by replacing every occurrence in this string of the given nonempty substring with the given replacement string, working from the start of this string to the end.

Returns a string formed by replacing the first occurrence in this string of the given nonempty substring, if any, with the given replacement string.

Returns a string formed by replacing the last occurrence in this string of the given nonempty substring, if any, with the given replacement string.

Determines if this string is shorter than the given length. This is a more efficient operation than string.size>length, since it does not require complete iteration of the underlying UTF-16-encoded native string.

Return two strings, the first containing the characters that occur before the given index, the second with the characters that occur after the given index. If the given index is outside the range of indices of this string, one of the returned strings will be empty.

Determines if this string occurs before the given string in lexicographic order, returning false if the two strings are equal.

A string containing the characters of this string occurring between the given indexes. If the start index is the same as the end index, return a string with a single character. If the start index is larger than the end index, return the characters in the reverse order from the order in which they occur in this string. If both the start index and the end index are larger than the last index in the string, or if both the start index and the end index are smaller than the first index in the string, return the empty string. Otherwise, if the last index is larger than the last index in the string, return all characters from the start index to last character of the string.

Using the span operator, string.span(to, from) may be written as string[from..to].

A string containing the characters of this string from the given start index inclusive to the end of the string. If the start index is larger than the last index of the string, return the empty string. If the start index is negative, return this string.

Using the span operator, string.spanFrom(from) may be written as string[from...].

A string containing the characters of this string from the start of the string up to and including the given end index. If the end index is negative, return the empty string. If the end index is larger than the last index in this string, return this string.

Using the span operator, string.spanTo(to) may be written as string[...to].

Split the string into tokens, using the given predicate function to determine which characters are separator characters delimiting token boundaries.

value pathElements = path.split('/'.equals);

The flags discardSeparators and groupSeparators determine how separator characters occur in the resulting stream.

• If discardSeparators is enabled, the stream contains only regular tokens containing adjacent non-separator characters, and the separator characters are simply discarded.
• If discardSeparators is disabled, the string is broken into regular tokens and separator tokens containing the separator characters. If groupSeparators is disabled, the separator tokens each contain a single character. If groupSeparators is enabled, adjacent separator characters are grouped into a single token.

The limit determines the maximum number of regular (non-separator) tokens that are returned in the stream. If the limit is exceeded, the remainder of the string is returned as a single token at the end of the resulting stream. For example,

"foo bar baz fum".split { limit = 2; }

produces the stream { "foo", "bar", "baz fum" }.

If the first character of this string is a separator character, the stream begins with an empty token. Likewise, if the last character of this string is a separator character, and the limit is not reached, the stream ends with an empty token.

Note that for the case of the empty string, split() always produces a stream containing a single empty token. For example:

"".split('/'.equals)

evaluates to the nonempty stream { "" }.

Determines if this string starts with the characters of the given string or list. Returns false if the given list contains an element that is not a Character.

A sublist of this list, starting at the element with index from, ending at the element with the index to.

This is a lazy operation, returning a view of this list.

A sublist of this list, starting at the element with the given index.

This is a lazy operation, returning a view of this list.

A sublist of this list, ending at the element with the given index.

This is a lazy operation, returning a view of this list.

A string containing the characters of this string beginning at the given start index, up to, but not including, the given end index. If the given end index is greater than the last index of this string, return the portion of the string from the given start index until the end of the string. If the start index is larger than the last index of the string, or if the end index is less than one or less than the start index, return the empty string.

For every pair of indexes, start, and end, and for any string:

string.substring(start, end) == string[start:end-start]

Note: this operation is provided to ease migration of code written in other languages. It is more idiomatic to use measure() or span() where reasonable.

The concatenation of the given strings.

Select the last characters of the string, returning a string no longer than the given length. If this string is shorter than the given length, return this string. Otherwise, return a string of the given length.

A string containing the characters of this string, after discarding the characters matching the given predicate function from the beginning and end of the string.

value trimmed = name.trim('_'.equals);

A character is removed from the string if it matches the given predicate and if either:

• every character occurring earlier in the string also matches the predicate, or
• every character occurring later in the string also matches the predicate.

A string containing the characters of this string, after discarding the characters matching the given predicate function from the beginning of the string.

A character is removed from the string if it matches the given predicate and every character occurring earlier in the string also matches the predicate.

A string containing the characters of this string, after discarding the characters matching the given predicate function from the end of the string.

A character is removed from the string if it matches the given predicate and every character occurring later in the string also matches the predicate.