commons.lang3.bridge.StringCommons.scala Maven / Gradle / Ivy

Checks if CharSequence contains a search CharSequence, handling `null`. This method uses {@link String# indexOf ( String )} if * possible.

A `none` CharSequence will return `false`.

Checks if CharSequence contains a search character, handling `null`. This method uses {@link String# indexOf ( int )} if * possible.

A `none` or empty ("") CharSequence will return `false`.

Checks if CharSequence contains a search character, handling `null`. This method uses {@link String# indexOf ( int )} if * possible.

A `none` or empty ("") CharSequence will return `false`.

Checks if the CharSequence contains any character or string in the given set of characters.

A `none` CharSequence will return `false`. A `null` search CharSequence will return `false`.

Checks if the CharSequence contains any of the CharSequences in the given array, ignoring case.

* * A `none` `cs` CharSequence will return `false`. * * A `null` or zero length search array will return `false`. * *

Checks if CharSequence contains a search CharSequence irrespective of case, handling `null`. Case-insensitivity is defined as by * [[String# equalsIgnoreCase ( String )]]. * *

A `none` CharSequence will return `false`.

Checks that the CharSequence does not contain certain characters.

* * A `none` CharSequence will return `true`. A `null` invalid character array will return `true`. An empty String ("") always returns * true.

Checks that the CharSequence does not contain certain option characters.

* * A `none` CharSequence will return `true`. A `None` invalid character array will return `true`. An empty String (Some("")) always * returns true.

Checks that the CharSequence does not contain certain characters.

A `none` CharSequence will return `true`. A `null` invalid character array will return `true`. An empty CharSequence (length()=0) * always returns true.

Checks if the CharSequence contains only certain characters.

A `none` CharSequence will return `false`. A `null` valid character String will return `false`. An empty String (length()=0) always * returns `true`.

Checks if the CharSequence contains only certain option characters.

A `none` CharSequence will return `false`. A `None` valid character String will return `false`. An empty String (length()=0) always * returns `true`.

Checks if the CharSequence contains only certain characters.

A `none` CharSequence will return `false`. A `null` valid character array will return `false`. An empty CharSequence (length()=0) * always returns `true`.

Check whether the given CharSequence contains any whitespace characters.

Whitespace is defined by [[Character# isWhitespace ( char )]].

Counts how many times the char appears in the given string.

A `none` or empty ("") String input returns `0`.

Counts how many times the substring appears in the larger string. Note that the code only counts non-overlapping matches.

A `none` or empty ("") String input returns `0`.

Counts how many times the substring appears in the larger string. Note that the code only counts non-overlapping matches.

A `null` or empty ("") String input returns `0`.

Returns either the passed in String, or if the String is `null`, an empty String ("").

Returns either the passed in String, or if the String is `null`, the value of `defaultStr`.

Deletes all whitespaces from a String as defined by {@link Character# isWhitespace ( char )}.

Compares two Strings, and returns the portion where they differ. More precisely, return the remainder of the second String, * starting from where it's different from the first. This means that the difference between "abc" and "ab" is the empty String and not * "c".

For example, `"i am a machine".ops.difference("i am a robot") -> "robot"`.

Check if a CharSequence ends with a specified suffix.

`null`s are handled without exceptions. Two `null` references are considered to be equal. The comparison is case sensitive.

Check if a CharSequence ends with any of the provided case-sensitive suffixes.

Case insensitive check if a CharSequence ends with a specified suffix.

`null`s are handled without exceptions. Two `null` references are considered to be equal. The comparison is case insensitive.

Compares two CharSequences, returning `true` if they represent equal sequences of characters.

`null`s are handled without exceptions. Two `null` references are considered to be equal. The comparison is case * sensitive.

Compares given `string` to a CharSequences vararg of `searchStrings`, returning `true` if the `string` is equal to any of the * `searchStrings`.

Compares two CharSequences, returning `true` if they represent equal sequences of characters, ignoring case.

`null`s are handled without exceptions. Two `null` references are considered equal. The comparison is case * insensitive.

Checks if a String `str`contains Unicode digits, if yes then concatenate all the digits in `str`and return it as a String.

An empty ("") String will be returned if no digits found in `str`.

Returns either the passed in CharSequence, or if the CharSequence is whitespace, empty ("") or `null`, the value supplied by * `defaultStrSupplier`.

Whitespace is defined by [[Character# isWhitespace ( char )]].

Caller responsible for thread-safety and exception handling of default value supplier

Finds the first index within a CharSequence, handling `null`. This method uses [[String# indexOf ( String, int)]] if possible.

A `null` CharSequence will return `-1`.

Finds the first index within a CharSequence, handling `null`. This method uses [[String# indexOf ( String, int)]] if possible.

A `null` CharSequence will return `-1`. A negative start position is treated as zero. An empty ("") search CharSequence always * matches. A start position greater than the string length only matches an empty search CharSequence.

Furthermore, a `null` or empty ("") CharSequence will return `INDEX_NOT_FOUND (-1)`.

Furthermore, a `null` or empty ("") CharSequence will return `INDEX_NOT_FOUND (-1)`.

If * a character with value `searchChar` occurs in the character sequence represented by the `seq` `CharSequence` object at an index no * smaller than `startPos`, then the index of the first such occurrence is returned. For values of `searchChar` in the range from 0 to * 0xFFFF (inclusive), this is the smallest value k such that: * {{{ * (this.charAt(k) == searchChar) && (k >= startPos) * }}} * is true. For other values of `searchChar`, it is the smallest value k such that: * {{{ * (this.codePointAt(k) == searchChar) && (k >= startPos) * }}} * is true. In either case, if no such character occurs in `seq` at or after position `startPos`, then `-1` is returned. * *

There is no restriction on the value of `startPos`. If it is negative, it has the same effect as if it were zero: this entire * string may be searched. If it is greater than the length of this string, it has the same effect as if it were equal to the length of * this string: `(INDEX_NOT_FOUND) -1` is returned. Furthermore, a `null` or empty ("") CharSequence will return `(INDEX_NOT_FOUND) -1`. * *

All indices are specified in `char` values (Unicode code units). * * {{{ * none.ops.indexof(*, *) = -1 * "".ops.indexof(*, *) = -1 * "aabaabaa".ops.indexOf('b', 0) = 2 * "aabaabaa".ops.indexOf('b', 3) = 5 * "aabaabaa".ops.indexOf('b', 9) = -1 * "aabaabaa".ops.indexOf'b', -1) = 2 * }}} * * @param searchChar * the character to find * @param startPos * the start position, negative treated as zero * @return * the first index of the search character (always ≥ startPos), * -1 if no match or `null` string input */ def indexOf(searchChar: Char, startPos: Int): Int = Strings.indexOf(strOrNull, searchChar, startPos) /** Returns the index within `seq` of the first occurrence of the specified character, starting the search at the specified index.

If * a character with value `searchChar` occurs in the character sequence represented by the `seq` `CharSequence` object at an index no * smaller than `startPos`, then the index of the first such occurrence is returned. For values of `searchChar` in the range from 0 to * 0xFFFF (inclusive), this is the smallest value k such that: * {{{ * (this.charAt(k) == searchChar) && (k >= startPos) * }}} * is true. For other values of `searchChar`, it is the smallest value k such that: * {{{ * (this.codePointAt(k) == searchChar) && (k >= startPos) * }}} * is true. In either case, if no such character occurs in `seq` at or after position `startPos`, then `-1` is returned. * *

There is no restriction on the value of `startPos`. If it is negative, it has the same effect as if it were zero: this entire * string may be searched. If it is greater than the length of this string, it has the same effect as if it were equal to the length of * this string: `(INDEX_NOT_FOUND) -1` is returned. Furthermore, a `null` or empty ("") CharSequence will return `(INDEX_NOT_FOUND) -1`. * *

All indices are specified in `char` values (Unicode code units). * * {{{ * none.ops.indexof(*, *) = -1 * "".ops.indexof(*, *) = -1 * "aabaabaa".ops.indexOf('b', 0) = 2 * "aabaabaa".ops.indexOf('b', 3) = 5 * "aabaabaa".ops.indexOf('b', 9) = -1 * "aabaabaa".ops.indexOf'b', -1) = 2 * }}} * * @param searchChar * the character to find * @param startPos * the start position, negative treated as zero * @return * the first index of the search character (always ≥ startPos), * -1 if no match or `null` string input */ def indexOf(searchChar: Int, startPos: Int): Int = Strings.indexOf(strOrNull, searchChar, startPos) /**

Search a CharSequence to find the first index of any character in the given set of characters.

A `null` String will return `-1`. A `null` or zero length search array will return `-1`.

Searches a CharSequence to find the first index of any character not in the given set of characters.

A `null` CharSequence will return `-1`. A `null` or zero length search array will return `-1`.

Search a CharSequence to find the first index of any character not in the given set of characters.

A `null` CharSequence will return `-1`. A `null` or empty search string will return `-1`.

Search a CharSequence to find the first index of any character not in the given set of characters.

A `null` CharSequence will return `-1`. A `null` or empty search string will return `-1`.

Compares all CharSequences in an array and returns the index at which the CharSequences begin to differ.

For example, `indexOfDifference(new String[] {"i am a machine", "i am a robot"`) -> 7}

Case in-sensitive find of the first index within a CharSequence.

A `null` CharSequence will return `-1`. A negative start position is treated as zero. An empty ("") search CharSequence always * matches. A start position greater than the string length only matches an empty search CharSequence.

Case in-sensitive find of the first index within a CharSequence from the specified position.

A `null` CharSequence will return `-1`. A negative start position is treated as zero. An empty ("") search CharSequence always * matches. A start position greater than the string length only matches an empty search CharSequence.

Checks if the CharSequence contains only lowercase characters.

`null` will return `false`. An empty CharSequence (length()=0) will return `false`.

Checks if the CharSequence contains only uppercase characters.

`null` will return `false`. An empty String (length()=0) will return `false`.

Checks if the CharSequence contains only Unicode letters.

`null` will return `false`. An empty CharSequence (length()=0) will return `false`.

Checks if the CharSequence contains only Unicode letters or digits.

`null` will return `false`. An empty CharSequence (length()=0) will return `false`.

Checks if the CharSequence contains only Unicode letters, digits or space (`' '`).

`null` will return `false`. An empty CharSequence (length()=0) will return `true`.

Checks if the CharSequence contains only Unicode letters and space (' ').

`null` will return `false` An empty CharSequence (length()=0) will return `true`.

Checks if the CharSequence contains only ASCII printable characters.

`null` will return `false`. An empty CharSequence (length()=0) will return `true`.

Checks if a CharSequence is empty (""), null or whitespace only.

Whitespace is defined by [[Character# isWhitespace ( char )]].

Checks if a CharSequence is empty ("") or null.

NOTE: This method changed in Lang version 2.0. It no longer trims the CharSequence. That functionality is available in * isBlank().

Checks if the CharSequence contains mixed casing of both uppercase and lowercase characters.

`null` will return `false`. An empty CharSequence (`length()=0`) will return `false`.

Checks if none of the CharSequences are empty (""), null or whitespace only.

Whitespace is defined by [[Character# isWhitespace ( char )]].

Checks if a CharSequence is not empty ("") and not null.

Checks if the CharSequence contains only Unicode digits. A decimal point is not a Unicode digit and returns false.

`null` will return `false`. An empty CharSequence (length()=0) will return `false`.

Note that the method does not allow for a leading sign, either positive or negative. Also, if a String passes the numeric test, it * may still generate a NumberFormatException when parsed by Integer.parseInt or Long.parseLong, e.g. if the value is outside the range * for int or long respectively.

Checks if the CharSequence contains only Unicode digits or space (`' '`). A decimal point is not a Unicode digit and returns * false.

`null` will return `false`. An empty CharSequence (length()=0) will return `true`.

Checks if the CharSequence contains only whitespace.

Whitespace is defined by [[Character# isWhitespace ( char )]].

`null` will return `false`. An empty CharSequence (length()=0) will return `true`.

Finds the last index within a CharSequence, handling `null`. This method uses [[String# lastIndexOf ( String, int)]] if * possible.

A `null` CharSequence will return `-1`. A negative start position returns `-1`. An empty ("") search CharSequence always matches * unless the start position is negative. A start position greater than the string length searches the whole string. The search starts at * the startPos and works backwards; matches starting after the start position are ignored.

 (this.charAt(k) == searchChar) && (k <= startPos) 

 (this.codePointAt(k) == searchChar)
    * && (k <= startPos) 

All indices are specified in `char` values (Unicode code units). * * {{{ * StringUtils.lastIndexOf(null, *, *) = -1 * StringUtils.lastIndexOf("", *, *) = -1 * StringUtils.lastIndexOf("aabaabaa", 'b', 8) = 5 * StringUtils.lastIndexOf("aabaabaa", 'b', 4) = 2 * StringUtils.lastIndexOf("aabaabaa", 'b', 0) = -1 * StringUtils.lastIndexOf("aabaabaa", 'b', 9) = 5 * StringUtils.lastIndexOf("aabaabaa", 'b', -1) = -1 * StringUtils.lastIndexOf("aabaabaa", 'a', 0) = 0 * }}} * * @param searchArg * the element to find * @param startPos * the start position * @tparam S * Char or CharSequence or Option[CharSequence] * @return * the last index of the search character (always ≤ startPos), * -1 if no match or `null` string input */ def lastIndexOf[S: TypeOptions4[*, Char, Int, CharSequence, Option[CharSequence]]](searchArg: S, startPos: Int): Int = { val mapping = TypeMapping.getMapping[TypeOptions4[*, Char, Int, CharSequence, Option[CharSequence]]] mapping .input(searchArg) .fold( ch => Strings.lastIndexOf(strOrNull, ch, startPos), i => Strings.lastIndexOf(strOrNull, i, startPos), str => Strings.lastIndexOf(strOrNull, str, startPos), ostr => Strings.indexOf(strOrNull, ostr.orNull, startPos) ) } /**

Find the latest index of any substring in a set of potential substrings.

A `null` CharSequence will return `-1`. A `null` search array will return `-1`. A `null` or zero length search array entry will be * ignored, but a search array containing "" will return the length of `str`if `str`is not null. This method uses * [[String# indexOf( String )]] if possible

Case in-sensitive find of the last index within a CharSequence.

A `null` CharSequence will return `-1`. A negative start position returns `-1`. An empty ("") search CharSequence always matches * unless the start position is negative. A start position greater than the string length searches the whole string.

Case in-sensitive find of the last index within a CharSequence from the specified position.

A `null` CharSequence will return `-1`. A negative start position returns `-1`. An empty ("") search CharSequence always matches * unless the start position is negative. A start position greater than the string length searches the whole string. The search starts at * the startPos and works backwards; matches starting after the start position are ignored.

Finds the n-th last index within a String, handling `null`. This method uses [[String# lastIndexOf ( String )]].

A `null` String will return `-1`.

Note that 'tail(CharSequence str, int n)' may be implemented as:

Gets the leftmost `len` characters of a String.

If `len` characters are not available, or the String is `null`, the String will be returned without an exception. An empty String * is returned if len is negative.

Left pad a String with spaces (' ').

The String is padded to the size of `size`.

Left pad a String with a specified character.

Pad to a size of `size`.

Left pad a String with a specified String.

Pad to a size of `size`.

Converts a String to lower case as per [[String # toLowerCase ( )]].

A `null` input String returns `null`.

Note: As described in the documentation for @[[String String#toLowerCase ( ) ]], the result of this method is * affected by the current locale. For platform-independent case transformations, the method [[String # lowerCase ( String, Locale)]] * should be used with a specific locale (e.g. [[Locale.ENGLISH Locale.ENGLISH]]).

Converts a String to lower case as per [[String# toLowerCase ( Locale )]].

A `null` input String returns `null`.

Gets `len` characters from the middle of a String.

If `len` characters are not available, the remainder of the String will be returned without an exception. If the String is `null`, * `null` will be returned. An empty String is returned if len is negative or exceeds the length of `str`.

Similar to http://www.w3.org/TR/xpath/#function-normalize * -space

The function returns the argument string with whitespace normalized by using [[trim trim(String)]] to remove * leading and trailing whitespace and then replacing sequences of whitespace characters by a single space.

Java's regexp pattern \s defines whitespace as [ \t\n\x0B\f\r] * *

For reference:

• \x0B = vertical tab
• \f = #xC = form feed
• #x20 = space
• #x9 = \t
• #xA * \= \n
• #xD = \r

The difference is that Java's whitespace includes vertical tab and form feed, which this functional will also normalize. * Additionally [[trim(String)]] removes control characters (char <= 32) from both ends of this String.

Finds the n-th index within a CharSequence, handling `null`. This method uses [[String# indexOf ( String )]] if possible.

Note: The code starts looking for a match at the start of the target, incrementing the starting index by one after each * successful match (unless `searchStr` is an empty string in which case the position is never incremented and `0` is returned * immediately). This means that matches may overlap.

A `null` CharSequence will return `-1`.

Matches may overlap:

Note that 'head(CharSequence str, int n)' may be implemented as:

Overlays part of a String with another String.

A `null` string input returns `None`. A negative index is treated as zero. An index greater than the string length is treated as * the string length. The start index is always the smaller of the two indices.

With additional prefixes,

With additional prefixes,

With additional prefixes,

With additional prefixes,

With additional prefixes,

With additional prefixes,

Removes all occurrences of a character from within the source string.

A `null` source string will return `null`. An empty ("") source string will return the empty string.

Removes all occurrences of a substring from within the source string.

A `null` source string will return `null`. An empty ("") source string will return the empty string. A `null` remove string will * return the source string. An empty ("") remove string will return the source string.

Removes a substring only if it is at the end of a source string, otherwise returns the source string.

A `null` source string will return `null`. An empty ("") source string will return the empty string. A `null` search string will * return the source string.

Case insensitive removal of a substring if it is at the end of a source string, otherwise returns the source string.

A `null` source string will return `null`. An empty ("") source string will return the empty string. A `null` search string will * return the source string.

Case insensitive removal of all occurrences of a substring from within the source string.

A `null` source string will return `null`. An empty ("") source string will return the empty string. A `null` remove string will * return the source string. An empty ("") remove string will return the source string.

Removes a substring only if it is at the beginning of a source string, otherwise returns the source string.

A `null` source string will return `null`. An empty ("") source string will return the empty string. A `null` search string will * return the source string.

Case insensitive removal of a substring if it is at the beginning of a source string, otherwise returns the source string.

A `null` source string will return `null`. An empty ("") source string will return the empty string. A `null` search string will * return the source string.

Repeat a String `repeat` times to form a new String.

Repeat a String `repeat` times to form a new String, with a String separator injected each time.

Replaces all occurrences of a String within another String.

A `null` reference passed to this method is a no-op.

Replaces a String with another String inside a larger String, for the first `max` values of the search String.

A `null` reference passed to this method is a no-op.

Replaces all occurrences of a character in a String with another. This is a null-safe version of * [[String# replace ( char,char)]].

A `null` string input returns `null`. An empty ("") string input returns an empty string.

Replaces multiple characters in a String in one go. This method can also be used to delete characters.

For example:
`replaceChars("hello", "ho", "jy") = jelly`.

A `null` string input returns `null`. An empty ("") string input returns an empty string. A null or empty set of search characters * returns the input string.

The length of the search characters should normally equal the length of the replace characters. If the search characters is longer, * then the extra search characters are deleted. If the search characters is shorter, then the extra replace characters are ignored.

Replaces all occurrences of Strings within another String.

A `null` reference passed to this method is a no-op, or if any "search string" or "string to replace" is null, that replace will * be ignored. This will not repeat. For repeating replaces, call the overloaded method.

Replaces all occurrences of Strings within another String.

A `null` reference passed to this method is a no-op, or if any "search string" or "string to replace" is null, that replace will * be ignored.

Case insensitively replaces a String with another String inside a larger String, for the first `max` values of the search * String.

A `null` reference passed to this method is a no-op.

Case insensitively replaces a String with another String inside a larger String, for the first `max` values of the search * String.

A `null` reference passed to this method is a no-op.

Replaces a String with another String inside a larger String, once.

A `null` reference passed to this method is a no-op.

Case insensitively replaces a String with another String inside a larger String, once.

A `null` reference passed to this method is a no-op.

Reverses a String as per [[StringBuilder# reverse ( )]].

A `null` String returns `null`.

Reverses a String that is delimited by a specific character.

The Strings between the delimiters are not reversed. Thus java.lang.String becomes String.lang.java (if the delimiter is * `'.'`).

Gets the rightmost `len` characters of a String.

If `len` characters are not available, or the String is `null`, the String will be returned without an an exception. An empty * String is returned if len is negative.

Right pad a String with spaces (' ').

The String is padded to the size of `size`.

Right pad a String with a specified character.

The String is padded to the size of `size`.

Right pad a String with a specified String.

The String is padded to the size of `size`.

Rotate (circular shift) a String of `shift` characters.

The separator is not included in the returned String array. Adjacent separators are treated as one separator. For more control over * the split use the StrTokenizer class.

A `none` input String returns `None`.

Splits the provided text into an array, separators specified. This is an alternative to using StringTokenizer.

The separator is not included in the returned String array. Adjacent separators are treated as one separator. For more control over * the split use the StrTokenizer class.

A `null` input String returns `null`. A `null` separatorChars splits on whitespace.

Splits the provided text into an array, separators specified. This is an alternative to using StringTokenizer.

The separator is not included in the returned String array. Adjacent separators are treated as one separator. For more control over * the split use the StrTokenizer class.

A `null` input String returns `null`. A `null` separatorChars splits on whitespace.

Splits the provided text into an array with a maximum length, separators specified.

The separator is not included in the returned String array. Adjacent separators are treated as one separator.

A `null` input String returns `null`. A `null` separatorChars splits on whitespace.

If more than `max` delimited substrings are found, the last returned string includes all characters after the first {@code max - 1} * returned strings (including separator characters).

Splits a String by Character type as returned by `java.lang.Character.getType(char)`. Groups of contiguous characters of the same * type are returned as complete tokens. * {{{ * none.ops.splitByCharacterType = null * "".ops.splitByCharacterType = [] * "ab de fg".ops.splitByCharacterType = ["ab", " ", "de", " ", "fg"] * "ab de fg".ops.splitByCharacterType = ["ab", " ", "de", " ", "fg"] * "ab:cd:ef".ops.splitByCharacterType = ["ab", ":", "cd", ":", "ef"] * "number5".ops.splitByCharacterType = ["number", "5"] * "fooBar".ops.splitByCharacterType = ["foo", "B", "ar"] * "foo200Bar".ops.splitByCharacterType = ["foo", "200", "B", "ar"] * "ASFRules".ops.splitByCharacterType = ["ASFR", "ules"] * }}} * * @return * an array of parsed Strings, `none` if none String input */ def splitByCharacterType: Option[Array[String]] = Option(Strings.splitByCharacterType(strOrNull)) /** *

Splits a String by Character type as returned by `java.lang.Character.getType(char)`. Groups of contiguous characters of the same * type are returned as complete tokens, with the following exception: the character of type `Character.UPPERCASE_LETTER`, if any, * immediately preceding a token of type `Character.LOWERCASE_LETTER` will belong to the following token rather than to the preceding, if * any, `Character.UPPERCASE_LETTER` token. * {{{ * none.ops.splitByCharacterTypeCamelCase = null * "".ops.splitByCharacterTypeCamelCase = [] * "ab de fg".ops.splitByCharacterTypeCamelCase = ["ab", " ", "de", " ", "fg"] * "ab de fg".ops.splitByCharacterTypeCamelCase = ["ab", " ", "de", " ", "fg"] * "ab:cd:ef".ops.splitByCharacterTypeCamelCase = ["ab", ":", "cd", ":", "ef"] * "number5".ops.splitByCharacterTypeCamelCase = ["number", "5"] * "fooBar".ops.splitByCharacterTypeCamelCase = ["foo", "Bar"] * "foo200Bar".ops.splitByCharacterTypeCamelCase = ["foo", "200", "Bar"] * "ASFRules".ops.splitByCharacterTypeCamelCase = ["ASF", "Rules"] * }}} * * @return * an array of parsed Strings, `none` if none String input */ def splitByCharacterTypeCamelCase: Option[Array[String]] = Option(Strings.splitByCharacterTypeCamelCase(strOrNull)) /**

Splits the provided text into an array, separator string specified. Returns a maximum of `max` substrings.

The separator(s) will not be included in the returned String array. Adjacent separators are treated as one separator.

A `null` input String returns `null`. A `null` separator splits on whitespace.

Splits the provided text into an array, separator string specified. Returns a maximum of `max` substrings.

The separator(s) will not be included in the returned String array. Adjacent separators are treated as one separator.

A `null` input String returns `null`. A `null` separator splits on whitespace.

Splits the provided text into an array, separator string specified.

The separator is not included in the returned String array. Adjacent separators are treated as separators for empty tokens. For * more control over the split use the StrTokenizer class.

A `null` input String returns `null`. A `null` separator splits on whitespace.

Splits the provided text into an array, separator string specified. Returns a maximum of `max` substrings.

The separator is not included in the returned String array. Adjacent separators are treated as separators for empty tokens. For * more control over the split use the StrTokenizer class.

A `null` input String returns `null`. A `null` separator splits on whitespace.

Splits the provided text into an array, using whitespace as the separator, preserving all tokens, including empty tokens created by * adjacent separators. This is an alternative to using StringTokenizer. Whitespace is defined by * [[Character# isWhitespace ( char)]].

The separator is not included in the returned String array. Adjacent separators are treated as separators for empty tokens. For * more control over the split use the StrTokenizer class.

A `null` input String returns `null`.

Splits the provided text into an array, separator specified, preserving all tokens, including empty tokens created by adjacent * separators. This is an alternative to using StringTokenizer.

The separator is not included in the returned String array. Adjacent separators are treated as separators for empty tokens. For * more control over the split use the StrTokenizer class.

A `null` input String returns `null`.

Splits the provided text into an array, separators specified, preserving all tokens, including empty tokens created by adjacent * separators. This is an alternative to using StringTokenizer.

The separator is not included in the returned String array. Adjacent separators are treated as separators for empty tokens. For * more control over the split use the StrTokenizer class.

A `null` input String returns `null`. A `null` separatorChars splits on whitespace.

Splits the provided text into an array with a maximum length, separators specified, preserving all tokens, including empty tokens * created by adjacent separators.

The separator is not included in the returned String array. Adjacent separators are treated as separators for empty tokens. * Adjacent separators are treated as one separator.

A `null` input String returns `null`. A `null` separatorChars splits on whitespace.

If more than `max` delimited substrings are found, the last returned string includes all characters after the first {@code max - 1} * returned strings (including separator characters).

Check if a CharSequence starts with a specified prefix.

`null`s are handled without exceptions. Two `null` references are considered to be equal. The comparison is case sensitive.

Case insensitive check if a CharSequence starts with a specified prefix.

`null`s are handled without exceptions. Two `null` references are considered to be equal. The comparison is case insensitive.

Case insensitive check if a CharSequence starts with a specified prefix.

`null`s are handled without exceptions. Two `null` references are considered to be equal. The comparison is case insensitive.

Strips whitespace from the start and end of a String.

This is similar to [[# trim ( String )]] but removes whitespace. Whitespace is defined by [[Character# isWhitespace ( char)]].

A `null` input String returns `null`.

Strips any of a set of characters from the start and end of a String. This is similar to [[String# trim ( )]] but allows the * characters to be stripped to be controlled.

A `null` input String returns `null`. An empty string ("") input returns the empty string.

If the stripChars String is `null`, whitespace is stripped as defined by [[Character# isWhitespace ( char )]]. Alternatively use * [[# strip ( String )]].

Removes diacritics (~= accents) from a string. The case will not be altered.

For instance, 'à' will be replaced by * 'a'.

Note that ligatures will be left as is.

Strips any of a set of characters from the end of a String.

A `null` input String returns `null`. An empty string ("") input returns the empty string.

If the stripChars String is `null`, whitespace is stripped as defined by [[Character# isWhitespace ( char )]].

Strips any of a set of characters from the end of a String.

A `null` input String returns `null`. An empty string ("") input returns the empty string.

If the stripChars String is `null`, whitespace is stripped as defined by [[Character# isWhitespace ( char )]].

Strips whitespace from the start and end of a String returning an empty String if `null` input.

This is similar to [[# trimToEmpty ( String )]] but removes whitespace. Whitespace is defined by * [[Character# isWhitespace( char )]].

Strips whitespace from the start and end of a String returning `null` if the String is empty ("") after the strip.

This is similar to [[# trimToNull ( String )]] but removes whitespace. Whitespace is defined by * [[Character# isWhitespace( char )]].

Gets a substring from the specified String avoiding exceptions.

A negative start position can be used to start `n` characters from the end of the String.

A `null` String will return `null`. An empty ("") String will return "".

Gets a substring from the specified String avoiding exceptions.

A negative start position can be used to start/end `n` characters from the end of the String.

The returned substring starts with the character in the `start` position and ends before the `end` position. All position counting * is zero-based -- i.e., to start at the beginning of the string use `start = 0`. Negative start and end positions can be used to * specify offsets relative to the end of the String.

If `start` is not strictly to the left of `end`, "" is returned.

Gets the substring after the first occurrence of a separator. The separator is not returned.

A `null` string input will return `null`. An empty ("") string input will return the empty string. * *

If nothing is found, the empty string is returned.

Gets the substring after the first occurrence of a separator. The separator is not returned.

A `null` string input will return `null`. An empty ("") string input will return the empty string. * *

If nothing is found, the empty string is returned.

Gets the substring after the first occurrence of a separator. The separator is not returned.

A `null` string input will return `null`. An empty ("") string input will return the empty string. A `null` separator will return * the empty string if the input string is not `null`.

If nothing is found, the empty string is returned.

Gets the substring after the last occurrence of a separator. The separator is not returned.

A `null` string input will return `null`. An empty ("") string input will return the empty string. * *

If nothing is found, the empty string is returned.

Gets the substring after the last occurrence of a separator. The separator is not returned.

A `null` string input will return `null`. An empty ("") string input will return the empty string. * *

If nothing is found, the empty string is returned.

Gets the substring after the last occurrence of a separator. The separator is not returned.

A `null` string input will return `null`. An empty ("") string input will return the empty string. An empty or {@code null} * separator will return the empty string if the input string is not `null`.

If nothing is found, the empty string is returned.

Gets the substring before the first occurrence of a separator. The separator is not returned.

A `null` string input will return `null`. An empty ("") string input will return the empty string.

If nothing is found, the string input is returned.

Gets the substring before the first occurrence of a separator. The separator is not returned.

A `null` string input will return `null`. An empty ("") string input will return the empty string.

If nothing is found, the string input is returned.

Gets the substring before the first occurrence of a separator. The separator is not returned.

A `null` string input will return `null`. An empty ("") string input will return the empty string. A `null` separator will return * the input string.

If nothing is found, the string input is returned.

Gets the substring before the last occurrence of a separator. The separator is not returned.

A `null` string input will return `null`. An empty ("") string input will return the empty string. An empty or {@code null} * separator will return the input string.

If nothing is found, the string input is returned.

Gets the String that is nested in between two instances of the same String.

A `null` input String returns `null`. A `null` tag returns `null`.

Gets the String that is nested in between two Strings. Only the first match is returned.

A `null` input String returns `null`. A `null` open/close returns `null` (no match). An empty ("") open and close returns an empty * string.

Searches a String for substrings delimited by a start and end tag, returning all matching substrings in an array.

A `null` input String returns `null`. A `null` open/close returns `null` (no match). An empty ("") open/close returns `null` (no * match).

Swaps the case of a String changing upper and title case to lower case, and lower case to upper case.

• Upper case character converts to Lower case
• Title case character converts to Lower case
• Lower case * character converts to Upper case

For a word based algorithm, see [[org.apache.commons.lang3.text.WordUtils# swapCase ( String )]]. A `none` input String returns * `None`.

NOTE: This method changed in Lang version 2.0. It no longer performs a word based algorithm. If you only use ASCII, you will notice * no change. That functionality is available in org.apache.commons.lang3.text.WordUtils.

Converts a `CharSequence` into an array of code points.

Valid pairs of surrogate code units will be converted into a single supplementary code point. Isolated surrogate code units (i.e. a * high surrogate not followed by a low surrogate or a low surrogate not preceded by a high surrogate) will be returned as-is.

Removes control characters (char <= 32) from both ends of this String, handling `null` by returning `null`.

The String is trimmed using [[String# trim ( )]]. Trim removes start and end characters <= 32. To strip whitespace use * [[# strip ( String )]].

To trim your choice of characters, use the [[# strip ( String, String)]] methods.

Removes control characters (char <= 32) from both ends of this String returning `null` if the String is empty ("") after the * trim or if it is `null`. * *

The String is trimmed using [[String# trim ( )]]. Trim removes start and end characters <= 32. To strip whitespace use * [[# stripToNull ( String )]].

Removes control characters (char <= 32) from both ends of this String returning `null` if the String is empty ("") after the * trim or if it is `null`. * *

The String is trimmed using [[String# trim ( )]]. Trim removes start and end characters <= 32. To strip whitespace use * [[# stripToNull ( String )]].

Truncates a String. This will turn "Now is the time for all good men" into "Now is the time for".

Specifically:

Truncates a String. This will turn "Now is the time for all good men" into "is the time for all".

Works like `truncate(String, int)`, but allows you to specify a "left edge" offset. * *

Specifically:

• If `str`is less than `maxWidth`characters long, return it.
• Else truncate it to `substring(str, * offset, maxWidth)`.
• If `maxWidth`is less than `0`, throw an {@code IllegalArgumentException}.
• If `offset` is less * than `0`, throw an `IllegalArgumentException`.
• In no case will it return a String of length greater than `maxWidth`.
*

Uncapitalizes a String, changing the first character to lower case as per [[Character# toLowerCase ( int )]]. No other characters * are changed.

For a word based algorithm, see [[org.apache.commons.lang3.text.WordUtils# uncapitalize ( String )]]. A `none` input String returns * `None`.

Unwraps a given string from a character.

Unwraps a given string from anther string.

Converts a String to upper case as per [[String# toUpperCase ( )]].

A `null` input String returns `null`.

Note: As described in the documentation for [[String# toUpperCase ( )]], the result of this method is affected by * the current locale. For platform-independent case transformations, the method [[# lowerCase ( String, Locale)]] should be used with a * specific locale (e.g. [[Locale# ENGLISH]]).

Converts a String to upper case as per {@link String# toUpperCase ( Locale )}.

A `null` input String returns `null`.

Wraps a string with a char.

Wraps a String with another String.

A `null` input String returns `null`.

Wraps a string with a char if that char is missing from the start or end of the given string.

A new `String` will not be created if `str`is already wrapped.

Wraps a string with a string if that string is missing from the start or end of the given string.

A new `String` will not be created if `str`is already wrapped.