Gets a CharSequence view for the argument character array.

The returned CharSequence will use the argument array for its underlying data.

Any modifications made to the array will be reflected on the returned char sequence.

The method may return a shared singleton object if the argument is empty.

Gets a CharSequence view for the argument character array with the given range.

The returned CharSequence will use the argument array for its underlying data.

Any modifications made to the array in the given range will be reflected on the returned char sequence.

The method may return a shared singleton object if the specified range is empty.

Gets a view for the iterable that creates an iterator that converts the elements of it to Strings.

Any modifications made to the argument will reflect on the returned iterable. The returned iterable creates iterators that support removal if and only if the argument supports removals.

Gets a forwarding iterator for the argument that converts the returned elements to Strings.

The returned iterator creates iterators that support removal if and only if the argument supports removals.

Compares two string in natural order with possible null values.

Any null values are ordered first.

Compares two string in natural order in an ignore-case manner with possible null values.

Any null values are ordered first.

Compares two string in natural order with possible null values.

Any null values are ordered last.

Compares two string in natural order in an ignore-case manner with possible null values.

Any null values are ordered last.

Counts the number of occurrences of a character in the given character sequence.

This method iterates over the characters of the sequence, and counts the occurrences of the specified character.

Checks if the given string ends with the specified prefix in a case-insensitive manner.

Searches the index of the line based on an index map and a character offset.

The method determines which is the corresponding line for the given character offset.

Creates an offset map for each line in the parameter string.

The parameter string is examined and each starting offset for each line is returned in the result array. The first element is always 0. The nth element in the array represents the offset for the nth line, and so on.

Each element in the resulting array represents the character offset in the parameter string where the given line starts.

The line ending is determined by the '\n' character.

Gets the position in the line for a given line index map and character offset.

This method searches the corresponding line for the offset and returns the offset in the found line.

Gets the position in the line for a given line, index map, and offset.

The parameter line index should be a result of getLineIndex(int[], int). It is not sanity checked if the line index is valid input, and it is the responsibility of the caller to call this method with appropriate parameters.
This method is only publicly available to avoid searching the line index multiple times if not necessary. If you don't use the line index directly, consider using getLinePositionIndex(int[], int) instead.

Converts a hexadecimal digit to integral value.

The argument must be a character in the range of '0' - '9', 'a' - 'f', 'A' - 'F' which is the range of the characters of a number in base 16.

Gets the index of the first occurrence of the given character in the argument char sequence.

Checks if the argument char sequence consists of only the given character.

An empty sequence is considered to consist only of the given character.

Checks if the argument string has an integral format.

A string is considered to be in integral format if it only contains numeric characters in the range of '0' - '9', and may be optionally prefixed by a sign character either '-' or '+'.

A string that only contains a single sign character is not considered to be integral.

Gets the index of the last occurrence of the given character in the argument char sequence.

Gets the length of the argument character sequence, returning 0 if null.

Gets a string that immediately follows the argument string given that they're ordered by natural order.

For the input string S, and result R, there are no string X for which the following is true:

 S < X < R
 

The returned string R will compare to be greater than the argument.

The returned string may have characters that are not displayable, or otherwise semantically incorrect. It should not be used in any other way than comparing other strings to it.

Gets the comparator that compares the argument strings by natural order, and orders nulls first if any.

Gets the comparator that compares the argument strings by natural order, and orders nulls last if any.

Converts a hexadecimal character sequence back to byte array representation.

The argument sequence length must be a multiply of 2 and contain only hexadecimal characters.

Removes the specified number of characters from the end of the given string.

Creates a string that has only the given character repeated in it the given number of times.

Creates an iterable that creates iterators that splits up the argument sequence by the given character.

The returned iterable will create iterators that work in the same way as splitCharSequenceIterator(CharSequence, char).

Creates an iterator that takes the argument sequence, and splits it up based on the given character.

The returned iterator will iterate over the split parts that doesn't contain the given character.

If multiple split characters occur after each other, the returned iterator will return empty sequences for the inner parts. If the character is at the start or end of the string, a preceeding and following empty sequence will be returned.

Checks if the given string starts with the specified prefix in a case-insensitive manner.

Gets a sub char sequence of the argument with the given range.

This method can be used when the caller doesn't want to use CharSequence.subSequence(int, int). This might be the case when the charsequence implementation would copy large amounts of data, create unnecessarily deep object hierarchy, or other arbitrary reasons.

This method will return a char sequence that forwards its calls to its subject. Any subsequence that is created on the result will not create long chaing of references, but will use the argument char sequence, only modifying the view range.

If the argument char sequence is already a type of the same type that this method would return, this will only call CharSequence.subSequence(int, int) on it, therefore there is no preformance penalty if this method is called with an object that was returned by this method.

Warning: This method takes an offset-length range instead of a start-end range, unlike CharSequence.subSequence(int, int).

If the created range is empty, this method may return a singleton shared object.

Converts the contents of the argument array to hexadecimal string representation.

Each byte will be split into two hexadecimal characters, where the 4 high order bits is the first character, and the 4 low order bits are the second.

Converts the contents in the given range of the argument array to hexadecimal string representation.

Each byte will be split into two hexadecimal characters, where the 4 high order bits is the first character, and the 4 low order bits are the second.

Converts the contents in the given range of the argument array to hexadecimal string representation and appends it to the given string builder.

Each byte will be split into two hexadecimal characters, where the 4 high order bits is the first character, and the 4 low order bits are the second.

Converts the contents of the argument array to hexadecimal string representation and appends it to the given string builder.

Each byte will be split into two hexadecimal characters, where the 4 high order bits is the first character, and the 4 low order bits are the second.

Creates a string representation of the argument elements with the specified format.

The method converts the given elements into string representation and joins them into a string with the given delimiter between them. The result is then prepended with the given prefix, and appended with the given suffix.

All arguments are nullable, in which case the corresponding part will not be appended to the result. If the elements are null, the delimiters won't be printed either. If all arguments are null, an empty string is returned.

Creates a string representation of the argument elements with the specified format.

The method converts the given elements into string representation and joins them into a string with the given delimiter between them. The result is then prepended with the given prefix, and appended with the given suffix.

All arguments are nullable, in which case the corresponding part will not be appended to the result. If the elements are null, the delimiters won't be printed either. If all arguments are null, an empty string is returned.

Creates a string representation of the argument elements with the specified format.

The method converts the given elements into string representation and joins them into a string with the given delimiter between them. The result is then prepended with the given prefix, and appended with the given suffix.

All arguments are nullable, in which case the corresponding part will not be appended to the result. If the elements are null, the delimiters won't be printed either. If all arguments are null, an empty string is returned.

Creates a string representation of the argument elements joined with the given delimiter.

Same as:

 toStringJoin(null, delimiter, elements, null);
 

Creates a string representation of the argument elements joined with the given delimiter.

Same as:

 toStringJoin(null, delimiter, elements, null);
 

Creates a string representation of the argument elements joined with the given delimiter.

Same as:

 toStringJoin(null, delimiter, elements, null);
 

Converts the argument objects to string representation, but limiting its length if it is longer than the maximum limit.

Converts the argument objects to string representation, but limiting its length if it is longer than the maximum limit, and adding an ellipsize if limited.

This method works the same way as toStringLimit(Object, int, String), but if the return value is actually limited by its length, then the ellipsize argument will be appended to it to signal that it got cropped.

Returns the argument string with quotes around it unless it is null.