```
public class StringUtils

                    
```
Operations on java.lang.String that are {@code null} safe.
- IsEmpty/IsBlank- checks if a String contains text
- Trim/Strip- removes leading and trailing whitespace
- Equals- compares two strings null-safe
- startsWith- check if a String starts with a prefix null-safe
- endsWith- check if a String ends with a suffix null-safe
- IndexOf/LastIndexOf/Contains- null-safe index-of checks
- IndexOfAny/LastIndexOfAny/IndexOfAnyBut/LastIndexOfAnyBut- index-of any of a set of Strings
- ContainsOnly/ContainsNone/ContainsAny- does String contains only/none/any of these characters
- Substring/Left/Right/Mid- null-safe substring extractions
- SubstringBefore/SubstringAfter/SubstringBetween- substring extraction relative to other strings
- Split/Join- splits a String into an array of substrings and vice versa
- Remove/Delete- removes part of a String
- Replace/Overlay- Searches a String and replaces one String with another
- Chomp/Chop- removes the last part of a String
- LeftPad/RightPad/Center/Repeat- pads a String
- UpperCase/LowerCase/SwapCase/Capitalize/Uncapitalize- changes the case of a String
- CountMatches- counts the number of occurrences of one String in another
- IsAlpha/IsNumeric/IsWhitespace/IsAsciiPrintable- checks the characters in a String
- DefaultString- protects against a null input String
- Reverse/ReverseDelimited- reverses a String
- Abbreviate- abbreviates a string using ellipsis
- Difference- compares Strings and reports on their differences
- LevenshteinDistance- the number of changes needed to change one String into another
The {@code StringUtils} class defines certain words related to String handling.
- null - {@code null}
- empty - a zero-length string ({@code ""})
- space - the space character ({@code ' '}, char 32)
- whitespace - the characters defined by isWhitespace
- trim - the characters <= 32 as in trim
{@code StringUtils} handles {@code null} input Strings quietly. That is to say that a {@code null} input will return {@code null}. Where a {@code boolean} or {@code int} is being returned details vary by method.
A side effect of the {@code null} handling is that a {@code NullPointerException} should be considered a bug in {@code StringUtils}.
Methods in this class give sample code to explain their operation. The symbol {@code *} is used to indicate any input including {@code null}.
#ThreadSafe#

Field Summary

Fields
Modifier and Type	Field	Description
`public final static String`	`EMPTY`
`public final static int`	`INDEX_NOT_FOUND`

Constructor Summary

Constructors
Constructor	Description
`StringUtils()`	`{@code StringUtils}` instances should NOT be constructed instandard programming.

Method Summary

Modifier and Type	Method	Description
`static boolean`	`isEmpty(CharSequence cs)`	Checks if a CharSequence is empty ("") or null.
`static boolean`	`isNotEmpty(CharSequence cs)`	Checks if a CharSequence is not empty ("") and not null.
`static boolean`	`isBlank(CharSequence cs)`	Checks if a CharSequence is whitespace, empty ("") or null.
`static boolean`	`isNotBlank(CharSequence cs)`	Checks if a CharSequence is not empty (""), not null and not whitespace only.
`static String`	`trim(String str)`	Removes control characters (char <= 32) from bothends of this String, handling `{@code null}` by returning `{@code null}`.
`static String`	`trimToNull(String str)`	Removes control characters (char <= 32) from bothends of this String returning `{@code null}` if the String isempty ("") after the trim or if it is `{@code null}`.
`static String`	`trimToEmpty(String str)`	Removes control characters (char <= 32) from bothends of this String returning an empty String ("") if the Stringis empty ("") after the trim or if it is `{@code null}`.
`static String`	`strip(String str)`	Strips whitespace from the start and end of a String.
`static String`	`stripToNull(String str)`	Strips whitespace from the start and end of a String returning `{@code null}` if the String is empty ("") after the strip.
`static String`	`stripToEmpty(String str)`	Strips whitespace from the start and end of a String returningan empty String if `{@code null}` input.
`static String`	`strip(String str, String stripChars)`	Strips any of a set of characters from the start and end of a String.
`static String`	`stripStart(String str, String stripChars)`	Strips any of a set of characters from the start of a String.
`static String`	`stripEnd(String str, String stripChars)`	Strips any of a set of characters from the end of a String.
`static Array<String>`	`stripAll(Array<String> strs)`	Strips whitespace from the start and end of every String in an array.
`static Array<String>`	`stripAll(Array<String> strs, String stripChars)`	Strips any of a set of characters from the start and end of everyString in an array.
`static String`	`stripAccents(String input)`	Removes diacritics (~= accents) from a string.
`static boolean`	`equals(CharSequence cs1, CharSequence cs2)`	Compares two CharSequences, returning `{@code true}` if they are equal.
`static boolean`	`equalsIgnoreCase(CharSequence str1, CharSequence str2)`	Compares two CharSequences, returning `{@code true}` if they are equal ignoringthe case.
`static int`	`indexOf(CharSequence seq, int searchChar)`	Finds the first index within a CharSequence, handling `{@code null}`.
`static int`	`indexOf(CharSequence seq, int searchChar, int startPos)`	Finds the first index within a CharSequence from a start position,handling `{@code null}`.
`static int`	`indexOf(CharSequence seq, CharSequence searchSeq)`	Finds the first index within a CharSequence, handling `{@code null}`.
`static int`	`indexOf(CharSequence seq, CharSequence searchSeq, int startPos)`	Finds the first index within a CharSequence, handling `{@code null}`.
`static int`	`ordinalIndexOf(CharSequence str, CharSequence searchStr, int ordinal)`	Finds the n-th index within a CharSequence, handling `{@code null}`.
`static int`	`indexOfIgnoreCase(CharSequence str, CharSequence searchStr)`	Case in-sensitive find of the first index within a CharSequence.
`static int`	`indexOfIgnoreCase(CharSequence str, CharSequence searchStr, int startPos)`	Case in-sensitive find of the first index within a CharSequencefrom the specified position.
`static int`	`lastIndexOf(CharSequence seq, int searchChar)`	Finds the last index within a CharSequence, handling `{@code null}`.
`static int`	`lastIndexOf(CharSequence seq, int searchChar, int startPos)`	Finds the last index within a CharSequence from a start position,handling `{@code null}`.
`static int`	`lastIndexOf(CharSequence seq, CharSequence searchSeq)`	Finds the last index within a CharSequence, handling `{@code null}`.
`static int`	`lastOrdinalIndexOf(CharSequence str, CharSequence searchStr, int ordinal)`	Finds the n-th last index within a String, handling `{@code null}`.
`static int`	`lastIndexOf(CharSequence seq, CharSequence searchSeq, int startPos)`	Finds the first index within a CharSequence, handling `{@code null}`.
`static int`	`lastIndexOfIgnoreCase(CharSequence str, CharSequence searchStr)`	Case in-sensitive find of the last index within a CharSequence.
`static int`	`lastIndexOfIgnoreCase(CharSequence str, CharSequence searchStr, int startPos)`	Case in-sensitive find of the last index within a CharSequencefrom the specified position.
`static boolean`	`contains(CharSequence seq, int searchChar)`	Checks if CharSequence contains a search character, handling `{@code null}`.
`static boolean`	`contains(CharSequence seq, CharSequence searchSeq)`	Checks if CharSequence contains a search CharSequence, handling `{@code null}`.
`static boolean`	`containsIgnoreCase(CharSequence str, CharSequence searchStr)`	Checks if CharSequence contains a search CharSequence irrespective of case,handling `{@code null}`.
`static boolean`	`containsWhitespace(CharSequence seq)`	Check whether the given CharSequence contains any whitespace characters.
`static int`	`indexOfAny(CharSequence cs, Array<char> searchChars)`	Search a CharSequence to find the first index of anycharacter in the given set of characters.
`static int`	`indexOfAny(CharSequence cs, String searchChars)`	Search a CharSequence to find the first index of anycharacter in the given set of characters.
`static boolean`	`containsAny(CharSequence cs, Array<char> searchChars)`	Checks if the CharSequence contains any character in the givenset of characters.
`static boolean`	`containsAny(CharSequence cs, CharSequence searchChars)`	Checks if the CharSequence contains any character in the given set of characters.
`static int`	`indexOfAnyBut(CharSequence cs, Array<char> searchChars)`	Searches a CharSequence to find the first index of anycharacter not in the given set of characters.
`static int`	`indexOfAnyBut(CharSequence seq, CharSequence searchChars)`	Search a CharSequence to find the first index of anycharacter not in the given set of characters.
`static boolean`	`containsOnly(CharSequence cs, Array<char> valid)`	Checks if the CharSequence contains only certain characters.
`static boolean`	`containsOnly(CharSequence cs, String validChars)`	Checks if the CharSequence contains only certain characters.
`static boolean`	`containsNone(CharSequence cs, Array<char> searchChars)`	Checks that the CharSequence does not contain certain characters.
`static boolean`	`containsNone(CharSequence cs, String invalidChars)`	Checks that the CharSequence does not contain certain characters.
`static int`	`indexOfAny(CharSequence str, Array<CharSequence> searchStrs)`	Find the first index of any of a set of potential substrings.
`static int`	`lastIndexOfAny(CharSequence str, Array<CharSequence> searchStrs)`	Find the latest index of any of a set of potential substrings.
`static String`	`substring(String str, int start)`	Gets a substring from the specified String avoiding exceptions.
`static String`	`substring(String str, int start, int end)`	Gets a substring from the specified String avoiding exceptions.
`static String`	`left(String str, int len)`	Gets the leftmost `{@code len}` characters of a String.
`static String`	`right(String str, int len)`	Gets the rightmost `{@code len}` characters of a String.
`static String`	`mid(String str, int pos, int len)`	Gets `{@code len}` characters from the middle of a String.
`static String`	`substringBefore(String str, String separator)`	Gets the substring before the first occurrence of a separator.The separator is not returned.
`static String`	`substringAfter(String str, String separator)`	Gets the substring after the first occurrence of a separator.The separator is not returned.
`static String`	`substringBeforeLast(String str, String separator)`	Gets the substring before the last occurrence of a separator.The separator is not returned.
`static String`	`substringAfterLast(String str, String separator)`	Gets the substring after the last occurrence of a separator.The separator is not returned.
`static String`	`substringBetween(String str, String tag)`	Gets the String that is nested in between two instances of thesame String.
`static String`	`substringBetween(String str, String open, String close)`	Gets the String that is nested in between two Strings.Only the first match is returned.
`static Array<String>`	`substringsBetween(String str, String open, String close)`	Searches a String for substrings delimited by a start and end tag,returning all matching substrings in an array.
`static Array<String>`	`split(String str)`	Splits the provided text into an array, using whitespace as theseparator.
`static Array<String>`	`split(String str, char separatorChar)`	Splits the provided text into an array, separator specified.This is an alternative to using StringTokenizer.
`static Array<String>`	`split(String str, String separatorChars)`	Splits the provided text into an array, separators specified.This is an alternative to using StringTokenizer.
`static Array<String>`	`split(String str, String separatorChars, int max)`	Splits the provided text into an array with a maximum length,separators specified.
`static Array<String>`	`splitByWholeSeparator(String str, String separator)`	Splits the provided text into an array, separator string specified.
`static Array<String>`	`splitByWholeSeparator(String str, String separator, int max)`	Splits the provided text into an array, separator string specified.
`static Array<String>`	`splitByWholeSeparatorPreserveAllTokens(String str, String separator)`	Splits the provided text into an array, separator string specified.
`static Array<String>`	`splitByWholeSeparatorPreserveAllTokens(String str, String separator, int max)`	Splits the provided text into an array, separator string specified.
`static Array<String>`	`splitPreserveAllTokens(String str)`	Splits the provided text into an array, using whitespace as theseparator, preserving all tokens, including empty tokens created byadjacent separators.
`static Array<String>`	`splitPreserveAllTokens(String str, char separatorChar)`	Splits the provided text into an array, separator specified,preserving all tokens, including empty tokens created by adjacentseparators.
`static Array<String>`	`splitPreserveAllTokens(String str, String separatorChars)`	Splits the provided text into an array, separators specified,preserving all tokens, including empty tokens created by adjacentseparators.
`static Array<String>`	`splitPreserveAllTokens(String str, String separatorChars, int max)`	Splits the provided text into an array with a maximum length,separators specified, preserving all tokens, including empty tokenscreated by adjacent separators.
`static Array<String>`	`splitByCharacterType(String str)`	Splits a String by Character type as returned by `{@code java.lang.Character.getType(char)}`.
`static Array<String>`	`splitByCharacterTypeCamelCase(String str)`	Splits a String by Character type as returned by `{@code java.lang.Character.getType(char)}`.
`static <T> String`	`join(Array<T> elements)`	Joins the elements of the provided array into a single Stringcontaining the provided list of elements.
`static String`	`join(Array<Object> array, char separator)`	Joins the elements of the provided array into a single Stringcontaining the provided list of elements.
`static String`	`join(Array<Object> array, char separator, int startIndex, int endIndex)`	Joins the elements of the provided array into a single Stringcontaining the provided list of elements.
`static String`	`join(Array<Object> array, String separator)`	Joins the elements of the provided array into a single Stringcontaining the provided list of elements.
`static String`	`join(Array<Object> array, String separator, int startIndex, int endIndex)`	Joins the elements of the provided array into a single Stringcontaining the provided list of elements.
`static String`	`join(Iterator<out Object> iterator, char separator)`	Joins the elements of the provided `{@code Iterator}` intoa single String containing the provided elements.
`static String`	`join(Iterator<out Object> iterator, String separator)`	Joins the elements of the provided `{@code Iterator}` intoa single String containing the provided elements.
`static String`	`join(Iterable<out Object> iterable, char separator)`	Joins the elements of the provided `{@code Iterable}` intoa single String containing the provided elements.
`static String`	`join(Iterable<out Object> iterable, String separator)`	Joins the elements of the provided `{@code Iterable}` intoa single String containing the provided elements.
`static String`	`deleteWhitespace(String str)`	Deletes all whitespaces from a String as defined by isWhitespace.
`static String`	`removeStart(String str, String remove)`	Removes a substring only if it is at the beginning of a source string,otherwise returns the source string.
`static String`	`removeStartIgnoreCase(String str, String remove)`	Case insensitive removal of a substring if it is at the beginning of a source string,otherwise returns the source string.
`static String`	`removeEnd(String str, String remove)`	Removes a substring only if it is at the end of a source string,otherwise returns the source string.
`static String`	`removeEndIgnoreCase(String str, String remove)`	Case insensitive removal of a substring if it is at the end of a source string,otherwise returns the source string.
`static String`	`remove(String str, String remove)`	Removes all occurrences of a substring from within the source string.
`static String`	`remove(String str, char remove)`	Removes all occurrences of a character from within the source string.
`static String`	`replaceOnce(String text, String searchString, String replacement)`	Replaces a String with another String inside a larger String, once.
`static String`	`replace(String text, String searchString, String replacement)`	Replaces all occurrences of a String within another String.
`static String`	`replace(String text, String searchString, String replacement, int max)`	Replaces a String with another String inside a larger String,for the first `{@code max}` values of the search String.
`static String`	`replaceEach(String text, Array<String> searchList, Array<String> replacementList)`	Replaces all occurrences of Strings within another String.
`static String`	`replaceEachRepeatedly(String text, Array<String> searchList, Array<String> replacementList)`	Replaces all occurrences of Strings within another String.
`static String`	`replaceChars(String str, char searchChar, char replaceChar)`	Replaces all occurrences of a character in a String with another.
`static String`	`replaceChars(String str, String searchChars, String replaceChars)`	Replaces multiple characters in a String in one go.This method can also be used to delete characters.
`static String`	`overlay(String str, String overlay, int start, int end)`	Overlays part of a String with another String.
`static String`	`chomp(String str)`	Removes one newline from end of a String if it's there,otherwise leave it alone.
`static String`	`chomp(String str, String separator)`	Removes `{@code separator}` from the end of `{@code str}` if it's there, otherwise leave it alone.
`static String`	`chop(String str)`	Remove the last character from a String.
`static String`	`repeat(String str, int repeat)`	Repeat a String `{@code repeat}` times to form anew String.
`static String`	`repeat(String str, String separator, int repeat)`	Repeat a String `{@code repeat}` times to form anew String, with a String separator injected each time.
`static String`	`repeat(char ch, int repeat)`	Returns padding using the specified delimiter repeatedto a given length.
`static String`	`rightPad(String str, int size)`	Right pad a String with spaces (' ').
`static String`	`rightPad(String str, int size, char padChar)`	Right pad a String with a specified character.
`static String`	`rightPad(String str, int size, String padStr)`	Right pad a String with a specified String.
`static String`	`leftPad(String str, int size)`	Left pad a String with spaces (' ').
`static String`	`leftPad(String str, int size, char padChar)`	Left pad a String with a specified character.
`static String`	`leftPad(String str, int size, String padStr)`	Left pad a String with a specified String.
`static int`	`length(CharSequence cs)`	Gets a CharSequence length or `{@code 0}` if the CharSequence is `{@code null}`.
`static String`	`center(String str, int size)`	Centers a String in a larger String of size `{@code size}` using the space character (' ').
`static String`	`center(String str, int size, char padChar)`	Centers a String in a larger String of size `{@code size}`.Uses a supplied character as the value to pad the String with.
`static String`	`center(String str, int size, String padStr)`	Centers a String in a larger String of size `{@code size}`.Uses a supplied String as the value to pad the String with.
`static String`	`upperCase(String str)`	Converts a String to upper case as per toUpperCase.
`static String`	`upperCase(String str, Locale locale)`	Converts a String to upper case as per toUpperCase.
`static String`	`lowerCase(String str)`	Converts a String to lower case as per toLowerCase.
`static String`	`lowerCase(String str, Locale locale)`	Converts a String to lower case as per toLowerCase.
`static String`	`capitalize(String str)`	Capitalizes a String changing the first letter to title case asper toTitleCase.
`static String`	`uncapitalize(String str)`	Uncapitalizes a String changing the first letter to title case asper toLowerCase.
`static String`	`swapCase(String str)`	Swaps the case of a String changing upper and title case tolower case, and lower case to upper case.
`static int`	`countMatches(CharSequence str, CharSequence sub)`	Counts how many times the substring appears in the larger string.
`static boolean`	`isAlpha(CharSequence cs)`	Checks if the CharSequence contains only Unicode letters.
`static boolean`	`isAlphaSpace(CharSequence cs)`	Checks if the CharSequence contains only Unicode letters andspace (' ').
`static boolean`	`isAlphanumeric(CharSequence cs)`	Checks if the CharSequence contains only Unicode letters or digits.
`static boolean`	`isAlphanumericSpace(CharSequence cs)`	Checks if the CharSequence contains only Unicode letters, digitsor space (`{@code ' '}`).
`static boolean`	`isAsciiPrintable(CharSequence cs)`	Checks if the CharSequence contains only ASCII printable characters.
`static boolean`	`isNumeric(CharSequence cs)`	Checks if the CharSequence contains only Unicode digits.A decimal point is not a Unicode digit and returns false.
`static boolean`	`isNumericSpace(CharSequence cs)`	Checks if the CharSequence contains only Unicode digits or space(`{@code ' '}`).A decimal point is not a Unicode digit and returns false.
`static boolean`	`isWhitespace(CharSequence cs)`	Checks if the CharSequence contains only whitespace.
`static boolean`	`isAllLowerCase(CharSequence cs)`	Checks if the CharSequence contains only lowercase characters.
`static boolean`	`isAllUpperCase(CharSequence cs)`	Checks if the CharSequence contains only uppercase characters.
`static String`	`defaultString(String str)`	Returns either the passed in String,or if the String is `{@code null}`, an empty String ("").
`static String`	`defaultString(String str, String defaultStr)`	Returns either the passed in String, or if the String is `{@code null}`, the value of `{@code defaultStr}`.
`static <T extends CharSequence> T`	`defaultIfBlank(T str, T defaultStr)`	Returns either the passed in CharSequence, or if the CharSequence iswhitespace, empty ("") or `{@code null}`, the value of `{@code defaultStr}`.
`static <T extends CharSequence> T`	`defaultIfEmpty(T str, T defaultStr)`	Returns either the passed in CharSequence, or if the CharSequence isempty or `{@code null}`, the value of `{@code defaultStr}`.
`static String`	`reverse(String str)`	Reverses a String as per reverse.
`static String`	`reverseDelimited(String str, char separatorChar)`	Reverses a String that is delimited by a specific character.
`static String`	`abbreviate(String str, int maxWidth)`	Abbreviates a String using ellipses.
`static String`	`abbreviate(String str, int offset, int maxWidth)`	Abbreviates a String using ellipses.
`static String`	`abbreviateMiddle(String str, String middle, int length)`	Abbreviates a String to the length passed, replacing the middle characters with the suppliedreplacement String.
`static String`	`difference(String str1, String str2)`	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.
`static int`	`indexOfDifference(CharSequence cs1, CharSequence cs2)`	Compares two CharSequences, and returns the index at which theCharSequences begin to differ.
`static int`	`indexOfDifference(Array<CharSequence> css)`	Compares all CharSequences in an array and returns the index at which theCharSequences begin to differ.
`static String`	`getCommonPrefix(Array<String> strs)`	Compares all Strings in an array and returns the initial sequence ofcharacters that is common to all of them.
`static int`	`getLevenshteinDistance(CharSequence s, CharSequence t)`	Find the Levenshtein distance between two Strings.
`static int`	`getLevenshteinDistance(CharSequence s, CharSequence t, int threshold)`	Find the Levenshtein distance between two Strings if it's less than or equal to a given threshold.
`static boolean`	`startsWith(CharSequence str, CharSequence prefix)`	Check if a CharSequence starts with a specified prefix.
`static boolean`	`startsWithIgnoreCase(CharSequence str, CharSequence prefix)`	Case insensitive check if a CharSequence starts with a specified prefix.
`static boolean`	`startsWithAny(CharSequence string, Array<CharSequence> searchStrings)`	Check if a CharSequence starts with any of an array of specified strings.
`static boolean`	`endsWith(CharSequence str, CharSequence suffix)`	Check if a CharSequence ends with a specified suffix.
`static boolean`	`endsWithIgnoreCase(CharSequence str, CharSequence suffix)`	Case insensitive check if a CharSequence ends with a specified suffix.
`static String`	`normalizeSpace(String str)`	Similar to http://www.w3.
`static boolean`	`endsWithAny(CharSequence string, Array<CharSequence> searchStrings)`	Check if a CharSequence ends with any of an array of specified strings.
`static String`	`toString(Array<byte> bytes, String charsetName)`	Converts a `byte[]` to a String using the specified character encoding.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail
- StringUtils
```
StringUtils()
```
  {@code StringUtils} instances should NOT be constructed instandard programming.

Method Detail

isEmpty

 static boolean isEmpty(CharSequence cs)

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

StringUtils.isEmpty(null)      = true
StringUtils.isEmpty("")        = true
StringUtils.isEmpty(" ")       = false
StringUtils.isEmpty("bob")     = false
StringUtils.isEmpty("  bob  ") = false

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

Parameters:: cs - the CharSequence to check, may be null

isNotEmpty

 static boolean isNotEmpty(CharSequence cs)

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

StringUtils.isNotEmpty(null)      = false
StringUtils.isNotEmpty("")        = false
StringUtils.isNotEmpty(" ")       = true
StringUtils.isNotEmpty("bob")     = true
StringUtils.isNotEmpty("  bob  ") = true

Parameters:: cs - the CharSequence to check, may be null

isBlank

 static boolean isBlank(CharSequence cs)

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

StringUtils.isBlank(null)      = true
StringUtils.isBlank("")        = true
StringUtils.isBlank(" ")       = true
StringUtils.isBlank("bob")     = false
StringUtils.isBlank("  bob  ") = false

Parameters:: cs - the CharSequence to check, may be null

isNotBlank

 static boolean isNotBlank(CharSequence cs)

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

StringUtils.isNotBlank(null)      = false
StringUtils.isNotBlank("")        = false
StringUtils.isNotBlank(" ")       = false
StringUtils.isNotBlank("bob")     = true
StringUtils.isNotBlank("  bob  ") = true

Parameters:: cs - the CharSequence to check, may be null

trim
```
 static String trim(String str)
```
Removes control characters (char <= 32) from bothends of this String, handling {@code null} by returning {@code null}.
The String is trimmed using trim.Trim removes start and end characters <= 32.To strip whitespace use strip.
To trim your choice of characters, use the strip methods.
```
StringUtils.trim(null)          = null
StringUtils.trim("")            = ""
StringUtils.trim("     ")       = ""
StringUtils.trim("abc")         = "abc"
StringUtils.trim("    abc    ") = "abc"
```
Parameters:

str - the String to be trimmed, may be null

trimToNull
```
 static String trimToNull(String str)
```
Removes control characters (char <= 32) from bothends of this String returning {@code null} if the String isempty ("") after the trim or if it is {@code null}.
The String is trimmed using trim.Trim removes start and end characters <= 32.To strip whitespace use stripToNull.
```
StringUtils.trimToNull(null)          = null
StringUtils.trimToNull("")            = null
StringUtils.trimToNull("     ")       = null
StringUtils.trimToNull("abc")         = "abc"
StringUtils.trimToNull("    abc    ") = "abc"
```
Parameters:

str - the String to be trimmed, may be null

trimToEmpty
```
 static String trimToEmpty(String str)
```
Removes control characters (char <= 32) from bothends of this String returning an empty String ("") if the Stringis empty ("") after the trim or if it is {@code null}.
The String is trimmed using trim.Trim removes start and end characters <= 32.To strip whitespace use stripToEmpty.
```
StringUtils.trimToEmpty(null)          = ""
StringUtils.trimToEmpty("")            = ""
StringUtils.trimToEmpty("     ")       = ""
StringUtils.trimToEmpty("abc")         = "abc"
StringUtils.trimToEmpty("    abc    ") = "abc"
```
Parameters:

str - the String to be trimmed, may be null

strip

 static String strip(String str)

Strips whitespace from the start and end of a String.

This is similar to trim but removes whitespace.Whitespace is defined by isWhitespace.

A {@code null} input String returns {@code null}.

StringUtils.strip(null)     = null
StringUtils.strip("")       = ""
StringUtils.strip("   ")    = ""
StringUtils.strip("abc")    = "abc"
StringUtils.strip("  abc")  = "abc"
StringUtils.strip("abc  ")  = "abc"
StringUtils.strip(" abc ")  = "abc"
StringUtils.strip(" ab c ") = "ab c"

Parameters:: str - the String to remove whitespace from, may be null

stripToNull

 static String stripToNull(String str)

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

This is similar to trimToNull but removes whitespace.Whitespace is defined by isWhitespace.

StringUtils.stripToNull(null)     = null
StringUtils.stripToNull("")       = null
StringUtils.stripToNull("   ")    = null
StringUtils.stripToNull("abc")    = "abc"
StringUtils.stripToNull("  abc")  = "abc"
StringUtils.stripToNull("abc  ")  = "abc"
StringUtils.stripToNull(" abc ")  = "abc"
StringUtils.stripToNull(" ab c ") = "ab c"

Parameters:: str - the String to be stripped, may be null

stripToEmpty

 static String stripToEmpty(String str)

Strips whitespace from the start and end of a String returningan empty String if {@code null} input.

This is similar to trimToEmpty but removes whitespace.Whitespace is defined by isWhitespace.

StringUtils.stripToEmpty(null)     = ""
StringUtils.stripToEmpty("")       = ""
StringUtils.stripToEmpty("   ")    = ""
StringUtils.stripToEmpty("abc")    = "abc"
StringUtils.stripToEmpty("  abc")  = "abc"
StringUtils.stripToEmpty("abc  ")  = "abc"
StringUtils.stripToEmpty(" abc ")  = "abc"
StringUtils.stripToEmpty(" ab c ") = "ab c"

Parameters:: str - the String to be stripped, may be null

strip
```
 static String strip(String str, String stripChars)
```
Strips any of a set of characters from the start and end of a String.This is similar to trim but allows the charactersto be stripped to be controlled.
A {@code null} input String returns {@code null}.An empty string ("") input returns the empty string.
If the stripChars String is {@code null}, whitespace isstripped as defined by isWhitespace.Alternatively use strip.
```
StringUtils.strip(null, *)          = null
StringUtils.strip("", *)            = ""
StringUtils.strip("abc", null)      = "abc"
StringUtils.strip("  abc", null)    = "abc"
StringUtils.strip("abc  ", null)    = "abc"
StringUtils.strip(" abc ", null)    = "abc"
StringUtils.strip("  abcyx", "xyz") = "  abc"
```
Parameters:

str - the String to remove characters from, may be null

stripChars - the characters to remove, null treated as whitespace

stripStart

 static String stripStart(String str, String stripChars)

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

A {@code null} input String returns {@code null}.An empty string ("") input returns the empty string.

If the stripChars String is {@code null}, whitespace isstripped as defined by isWhitespace.

StringUtils.stripStart(null, *)          = null
StringUtils.stripStart("", *)            = ""
StringUtils.stripStart("abc", "")        = "abc"
StringUtils.stripStart("abc", null)      = "abc"
StringUtils.stripStart("  abc", null)    = "abc"
StringUtils.stripStart("abc  ", null)    = "abc  "
StringUtils.stripStart(" abc ", null)    = "abc "
StringUtils.stripStart("yxabc  ", "xyz") = "abc  "

Parameters:: str - the String to remove characters from, may be null; stripChars - the characters to remove, null treated as whitespace

stripEnd

 static String stripEnd(String str, String stripChars)

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

A {@code null} input String returns {@code null}.An empty string ("") input returns the empty string.

If the stripChars String is {@code null}, whitespace isstripped as defined by isWhitespace.

StringUtils.stripEnd(null, *)          = null
StringUtils.stripEnd("", *)            = ""
StringUtils.stripEnd("abc", "")        = "abc"
StringUtils.stripEnd("abc", null)      = "abc"
StringUtils.stripEnd("  abc", null)    = "  abc"
StringUtils.stripEnd("abc  ", null)    = "abc"
StringUtils.stripEnd(" abc ", null)    = " abc"
StringUtils.stripEnd("  abcyx", "xyz") = "  abc"
StringUtils.stripEnd("120.00", ".0")   = "12"

Parameters:: str - the String to remove characters from, may be null; stripChars - the set of characters to remove, null treated as whitespace

stripAll
```
 static Array<String> stripAll(Array<String> strs)
```
Strips whitespace from the start and end of every String in an array.Whitespace is defined by isWhitespace.
A new array is returned each time, except for length zero.A {@code null} array will return {@code null}.An empty array will return itself.A {@code null} array entry will be ignored.
```
StringUtils.stripAll(null)             = null
StringUtils.stripAll([])               = []
StringUtils.stripAll(["abc", "  abc"]) = ["abc", "abc"]
StringUtils.stripAll(["abc  ", null])  = ["abc", null]
```
Parameters:

strs - the array to remove whitespace from, may be null

stripAll
```
 static Array<String> stripAll(Array<String> strs, String stripChars)
```
Strips any of a set of characters from the start and end of everyString in an array.
Whitespace is defined by isWhitespace.
A new array is returned each time, except for length zero.A {@code null} array will return {@code null}.An empty array will return itself.A {@code null} array entry will be ignored.A {@code null} stripChars will strip whitespace as defined by isWhitespace.
```
StringUtils.stripAll(null, *)                = null
StringUtils.stripAll([], *)                  = []
StringUtils.stripAll(["abc", "  abc"], null) = ["abc", "abc"]
StringUtils.stripAll(["abc  ", null], null)  = ["abc", null]
StringUtils.stripAll(["abc  ", null], "yz")  = ["abc  ", null]
StringUtils.stripAll(["yabcz", null], "yz")  = ["abc", null]
```
Parameters:

strs - the array to remove characters from, may be null

stripChars - the characters to remove, null treated as whitespace

stripAccents
```
 static String stripAccents(String input)
```
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.
This method will use the first available implementation of:Java 6's java.text.Normalizer, Java 1.3–1.5's {@code sun.text.Normalizer}
```
StringUtils.stripAccents(null)                = null
StringUtils.stripAccents("")                  = ""
StringUtils.stripAccents("control")           = "control"
StringUtils.stripAccents("éclair")     = "eclair"
```
Parameters:

input - String to be stripped

equals
```
 static boolean equals(CharSequence cs1, CharSequence cs2)
```
Compares two CharSequences, returning {@code true} if they are equal.
{@code null}s are handled without exceptions. Two {@code null} references are considered to be equal. The comparison is case sensitive.
```
StringUtils.equals(null, null)   = true
StringUtils.equals(null, "abc")  = false
StringUtils.equals("abc", null)  = false
StringUtils.equals("abc", "abc") = true
StringUtils.equals("abc", "ABC") = false
```
Parameters:

cs1 - the first CharSequence, may be null

cs2 - the second CharSequence, may be null

equalsIgnoreCase

 static boolean equalsIgnoreCase(CharSequence str1, CharSequence str2)

Compares two CharSequences, returning {@code true} if they are equal ignoringthe case.

{@code null}s are handled without exceptions. Two {@code null} references are considered equal. Comparison is case insensitive.

StringUtils.equalsIgnoreCase(null, null)   = true
StringUtils.equalsIgnoreCase(null, "abc")  = false
StringUtils.equalsIgnoreCase("abc", null)  = false
StringUtils.equalsIgnoreCase("abc", "abc") = true
StringUtils.equalsIgnoreCase("abc", "ABC") = true

Parameters:: str1 - the first CharSequence, may be null; str2 - the second CharSequence, may be null

indexOf
```
 static int indexOf(CharSequence seq, int searchChar)
```
Finds the first index within a CharSequence, handling {@code null}.This method uses indexOf if possible.
A {@code null} or empty ("") CharSequence will return {@code INDEX_NOT_FOUND (-1)}.
```
StringUtils.indexOf(null, *)         = -1
StringUtils.indexOf("", *)           = -1
StringUtils.indexOf("aabaabaa", 'a') = 0
StringUtils.indexOf("aabaabaa", 'b') = 2
```
Parameters:

seq - the CharSequence to check, may be null

searchChar - the character to find

indexOf
```
 static int indexOf(CharSequence seq, int searchChar, int startPos)
```
Finds the first index within a CharSequence from a start position,handling {@code null}.This method uses indexOf if possible.
A {@code null} or empty ("") CharSequence will return {@code (INDEX_NOT_FOUND) -1}.A negative start position is treated as zero.A start position greater than the string length returns {@code -1}.
```
StringUtils.indexOf(null, *, *)          = -1
StringUtils.indexOf("", *, *)            = -1
StringUtils.indexOf("aabaabaa", 'b', 0)  = 2
StringUtils.indexOf("aabaabaa", 'b', 3)  = 5
StringUtils.indexOf("aabaabaa", 'b', 9)  = -1
StringUtils.indexOf("aabaabaa", 'b', -1) = 2
```
Parameters:

seq - the CharSequence to check, may be null

searchChar - the character to find

startPos - the start position, negative treated as zero

indexOf

 static int indexOf(CharSequence seq, CharSequence searchSeq)

Finds the first index within a CharSequence, handling {@code null}.This method uses indexOf if possible.

A {@code null} CharSequence will return {@code -1}.

StringUtils.indexOf(null, *)          = -1
StringUtils.indexOf(*, null)          = -1
StringUtils.indexOf("", "")           = 0
StringUtils.indexOf("", *)            = -1 (except when * = "")
StringUtils.indexOf("aabaabaa", "a")  = 0
StringUtils.indexOf("aabaabaa", "b")  = 2
StringUtils.indexOf("aabaabaa", "ab") = 1
StringUtils.indexOf("aabaabaa", "")   = 0

Parameters:: seq - the CharSequence to check, may be null; searchSeq - the CharSequence to find, may be null

indexOf

 static int indexOf(CharSequence seq, CharSequence searchSeq, int startPos)

Finds the first index within a CharSequence, handling {@code null}.This method uses indexOf if possible.

A {@code null} CharSequence will return {@code -1}.A negative start position is treated as zero.An empty ("") search CharSequence always matches.A start position greater than the string length only matchesan empty search CharSequence.

StringUtils.indexOf(null, *, *)          = -1
StringUtils.indexOf(*, null, *)          = -1
StringUtils.indexOf("", "", 0)           = 0
StringUtils.indexOf("", *, 0)            = -1 (except when * = "")
StringUtils.indexOf("aabaabaa", "a", 0)  = 0
StringUtils.indexOf("aabaabaa", "b", 0)  = 2
StringUtils.indexOf("aabaabaa", "ab", 0) = 1
StringUtils.indexOf("aabaabaa", "b", 3)  = 5
StringUtils.indexOf("aabaabaa", "b", 9)  = -1
StringUtils.indexOf("aabaabaa", "b", -1) = 2
StringUtils.indexOf("aabaabaa", "", 2)   = 2
StringUtils.indexOf("abc", "", 9)        = 3

Parameters:: seq - the CharSequence to check, may be null; searchSeq - the CharSequence to find, may be null; startPos - the start position, negative treated as zero

ordinalIndexOf

 static int ordinalIndexOf(CharSequence str, CharSequence searchStr, int ordinal)

Finds the n-th index within a CharSequence, handling {@code null}.This method uses indexOf if possible.

A {@code null} CharSequence will return {@code -1}.

StringUtils.ordinalIndexOf(null, *, *)          = -1
StringUtils.ordinalIndexOf(*, null, *)          = -1
StringUtils.ordinalIndexOf("", "", *)           = 0
StringUtils.ordinalIndexOf("aabaabaa", "a", 1)  = 0
StringUtils.ordinalIndexOf("aabaabaa", "a", 2)  = 1
StringUtils.ordinalIndexOf("aabaabaa", "b", 1)  = 2
StringUtils.ordinalIndexOf("aabaabaa", "b", 2)  = 5
StringUtils.ordinalIndexOf("aabaabaa", "ab", 1) = 1
StringUtils.ordinalIndexOf("aabaabaa", "ab", 2) = 4
StringUtils.ordinalIndexOf("aabaabaa", "", 1)   = 0
StringUtils.ordinalIndexOf("aabaabaa", "", 2)   = 0

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

  str.substring(0, lastOrdinalIndexOf(str, "\n", n))

Parameters:: str - the CharSequence to check, may be null; searchStr - the CharSequence to find, may be null; ordinal - the n-th {@code searchStr} to find

indexOfIgnoreCase
```
 static int indexOfIgnoreCase(CharSequence str, CharSequence searchStr)
```
Case in-sensitive find of the first index within a CharSequence.
A {@code null} CharSequence will return {@code -1}.A negative start position is treated as zero.An empty ("") search CharSequence always matches.A start position greater than the string length only matchesan empty search CharSequence.
```
StringUtils.indexOfIgnoreCase(null, *)          = -1
StringUtils.indexOfIgnoreCase(*, null)          = -1
StringUtils.indexOfIgnoreCase("", "")           = 0
StringUtils.indexOfIgnoreCase("aabaabaa", "a")  = 0
StringUtils.indexOfIgnoreCase("aabaabaa", "b")  = 2
StringUtils.indexOfIgnoreCase("aabaabaa", "ab") = 1
```
Parameters:

str - the CharSequence to check, may be null

searchStr - the CharSequence to find, may be null

indexOfIgnoreCase

 static int indexOfIgnoreCase(CharSequence str, CharSequence searchStr, int startPos)

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

A {@code null} CharSequence will return {@code -1}.A negative start position is treated as zero.An empty ("") search CharSequence always matches.A start position greater than the string length only matchesan empty search CharSequence.

StringUtils.indexOfIgnoreCase(null, *, *)          = -1
StringUtils.indexOfIgnoreCase(*, null, *)          = -1
StringUtils.indexOfIgnoreCase("", "", 0)           = 0
StringUtils.indexOfIgnoreCase("aabaabaa", "A", 0)  = 0
StringUtils.indexOfIgnoreCase("aabaabaa", "B", 0)  = 2
StringUtils.indexOfIgnoreCase("aabaabaa", "AB", 0) = 1
StringUtils.indexOfIgnoreCase("aabaabaa", "B", 3)  = 5
StringUtils.indexOfIgnoreCase("aabaabaa", "B", 9)  = -1
StringUtils.indexOfIgnoreCase("aabaabaa", "B", -1) = 2
StringUtils.indexOfIgnoreCase("aabaabaa", "", 2)   = 2
StringUtils.indexOfIgnoreCase("abc", "", 9)        = 3

Parameters:: str - the CharSequence to check, may be null; searchStr - the CharSequence to find, may be null; startPos - the start position, negative treated as zero

lastIndexOf
```
 static int lastIndexOf(CharSequence seq, int searchChar)
```
Finds the last index within a CharSequence, handling {@code null}.This method uses lastIndexOf if possible.
A {@code null} or empty ("") CharSequence will return {@code -1}.
```
StringUtils.lastIndexOf(null, *)         = -1
StringUtils.lastIndexOf("", *)           = -1
StringUtils.lastIndexOf("aabaabaa", 'a') = 7
StringUtils.lastIndexOf("aabaabaa", 'b') = 5
```
Parameters:

seq - the CharSequence to check, may be null

searchChar - the character to find

lastIndexOf

 static int lastIndexOf(CharSequence seq, int searchChar, int startPos)

Finds the last index within a CharSequence from a start position,handling {@code null}.This method uses lastIndexOf if possible.

A {@code null} or empty ("") CharSequence will return {@code -1}.A negative start position returns {@code -1}.A start position greater than the string length searches the whole string.

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

Parameters:: seq - the CharSequence to check, may be null; searchChar - the character to find; startPos - the start position

lastIndexOf

 static int lastIndexOf(CharSequence seq, CharSequence searchSeq)

Finds the last index within a CharSequence, handling {@code null}.This method uses lastIndexOf if possible.

A {@code null} CharSequence will return {@code -1}.

StringUtils.lastIndexOf(null, *)          = -1
StringUtils.lastIndexOf(*, null)          = -1
StringUtils.lastIndexOf("", "")           = 0
StringUtils.lastIndexOf("aabaabaa", "a")  = 7
StringUtils.lastIndexOf("aabaabaa", "b")  = 5
StringUtils.lastIndexOf("aabaabaa", "ab") = 4
StringUtils.lastIndexOf("aabaabaa", "")   = 8

Parameters:: seq - the CharSequence to check, may be null; searchSeq - the CharSequence to find, may be null

lastOrdinalIndexOf

 static int lastOrdinalIndexOf(CharSequence str, CharSequence searchStr, int ordinal)

Finds the n-th last index within a String, handling {@code null}.This method uses lastIndexOf.

A {@code null} String will return {@code -1}.

StringUtils.lastOrdinalIndexOf(null, *, *)          = -1
StringUtils.lastOrdinalIndexOf(*, null, *)          = -1
StringUtils.lastOrdinalIndexOf("", "", *)           = 0
StringUtils.lastOrdinalIndexOf("aabaabaa", "a", 1)  = 7
StringUtils.lastOrdinalIndexOf("aabaabaa", "a", 2)  = 6
StringUtils.lastOrdinalIndexOf("aabaabaa", "b", 1)  = 5
StringUtils.lastOrdinalIndexOf("aabaabaa", "b", 2)  = 2
StringUtils.lastOrdinalIndexOf("aabaabaa", "ab", 1) = 4
StringUtils.lastOrdinalIndexOf("aabaabaa", "ab", 2) = 1
StringUtils.lastOrdinalIndexOf("aabaabaa", "", 1)   = 8
StringUtils.lastOrdinalIndexOf("aabaabaa", "", 2)   = 8

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

  str.substring(lastOrdinalIndexOf(str, "\n", n) + 1)

Parameters:: str - the CharSequence to check, may be null; searchStr - the CharSequence to find, may be null; ordinal - the n-th last {@code searchStr} to find

lastIndexOf

 static int lastIndexOf(CharSequence seq, CharSequence searchSeq, int startPos)

Finds the first index within a CharSequence, handling {@code null}.This method uses lastIndexOf if possible.

A {@code null} CharSequence will return {@code -1}.A negative start position returns {@code -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.

StringUtils.lastIndexOf(null, *, *)          = -1
StringUtils.lastIndexOf(*, null, *)          = -1
StringUtils.lastIndexOf("aabaabaa", "a", 8)  = 7
StringUtils.lastIndexOf("aabaabaa", "b", 8)  = 5
StringUtils.lastIndexOf("aabaabaa", "ab", 8) = 4
StringUtils.lastIndexOf("aabaabaa", "b", 9)  = 5
StringUtils.lastIndexOf("aabaabaa", "b", -1) = -1
StringUtils.lastIndexOf("aabaabaa", "a", 0)  = 0
StringUtils.lastIndexOf("aabaabaa", "b", 0)  = -1

Parameters:: seq - the CharSequence to check, may be null; searchSeq - the CharSequence to find, may be null; startPos - the start position, negative treated as zero

lastIndexOfIgnoreCase
```
 static int lastIndexOfIgnoreCase(CharSequence str, CharSequence searchStr)
```
Case in-sensitive find of the last index within a CharSequence.
A {@code null} CharSequence will return {@code -1}.A negative start position returns {@code -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.
```
StringUtils.lastIndexOfIgnoreCase(null, *)          = -1
StringUtils.lastIndexOfIgnoreCase(*, null)          = -1
StringUtils.lastIndexOfIgnoreCase("aabaabaa", "A")  = 7
StringUtils.lastIndexOfIgnoreCase("aabaabaa", "B")  = 5
StringUtils.lastIndexOfIgnoreCase("aabaabaa", "AB") = 4
```
Parameters:

str - the CharSequence to check, may be null

searchStr - the CharSequence to find, may be null

lastIndexOfIgnoreCase

 static int lastIndexOfIgnoreCase(CharSequence str, CharSequence searchStr, int startPos)

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

A {@code null} CharSequence will return {@code -1}.A negative start position returns {@code -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.

StringUtils.lastIndexOfIgnoreCase(null, *, *)          = -1
StringUtils.lastIndexOfIgnoreCase(*, null, *)          = -1
StringUtils.lastIndexOfIgnoreCase("aabaabaa", "A", 8)  = 7
StringUtils.lastIndexOfIgnoreCase("aabaabaa", "B", 8)  = 5
StringUtils.lastIndexOfIgnoreCase("aabaabaa", "AB", 8) = 4
StringUtils.lastIndexOfIgnoreCase("aabaabaa", "B", 9)  = 5
StringUtils.lastIndexOfIgnoreCase("aabaabaa", "B", -1) = -1
StringUtils.lastIndexOfIgnoreCase("aabaabaa", "A", 0)  = 0
StringUtils.lastIndexOfIgnoreCase("aabaabaa", "B", 0)  = -1

Parameters:: str - the CharSequence to check, may be null; searchStr - the CharSequence to find, may be null; startPos - the start position

contains
```
 static boolean contains(CharSequence seq, int searchChar)
```
Checks if CharSequence contains a search character, handling {@code null}.This method uses indexOf if possible.
A {@code null} or empty ("") CharSequence will return {@code false}.
```
StringUtils.contains(null, *)    = false
StringUtils.contains("", *)      = false
StringUtils.contains("abc", 'a') = true
StringUtils.contains("abc", 'z') = false
```
Parameters:

seq - the CharSequence to check, may be null

searchChar - the character to find

contains

 static boolean contains(CharSequence seq, CharSequence searchSeq)

Checks if CharSequence contains a search CharSequence, handling {@code null}.This method uses indexOf if possible.

A {@code null} CharSequence will return {@code false}.

StringUtils.contains(null, *)     = false
StringUtils.contains(*, null)     = false
StringUtils.contains("", "")      = true
StringUtils.contains("abc", "")   = true
StringUtils.contains("abc", "a")  = true
StringUtils.contains("abc", "z")  = false

Parameters:: seq - the CharSequence to check, may be null; searchSeq - the CharSequence to find, may be null

containsIgnoreCase

 static boolean containsIgnoreCase(CharSequence str, CharSequence searchStr)

Checks if CharSequence contains a search CharSequence irrespective of case,handling {@code null}. Case-insensitivity is defined as by equalsIgnoreCase.

A {@code null} CharSequence will return {@code false}.

StringUtils.contains(null, *) = false
StringUtils.contains(*, null) = false
StringUtils.contains("", "") = true
StringUtils.contains("abc", "") = true
StringUtils.contains("abc", "a") = true
StringUtils.contains("abc", "z") = false
StringUtils.contains("abc", "A") = true
StringUtils.contains("abc", "Z") = false

Parameters:: str - the CharSequence to check, may be null; searchStr - the CharSequence to find, may be null

containsWhitespace
```
 static boolean containsWhitespace(CharSequence seq)
```
Check whether the given CharSequence contains any whitespace characters.

Parameters:

seq - the CharSequence to check (may be {@code null})

indexOfAny

 static int indexOfAny(CharSequence cs, Array<char> searchChars)

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

A {@code null} String will return {@code -1}.A {@code null} or zero length search array will return {@code -1}.

StringUtils.indexOfAny(null, *)                = -1
StringUtils.indexOfAny("", *)                  = -1
StringUtils.indexOfAny(*, null)                = -1
StringUtils.indexOfAny(*, [])                  = -1
StringUtils.indexOfAny("zzabyycdxx",['z','a']) = 0
StringUtils.indexOfAny("zzabyycdxx",['b','y']) = 3
StringUtils.indexOfAny("aba", ['z'])           = -1

Parameters:: cs - the CharSequence to check, may be null; searchChars - the chars to search for, may be null

indexOfAny

 static int indexOfAny(CharSequence cs, String searchChars)

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

A {@code null} String will return {@code -1}.A {@code null} search string will return {@code -1}.

StringUtils.indexOfAny(null, *)            = -1
StringUtils.indexOfAny("", *)              = -1
StringUtils.indexOfAny(*, null)            = -1
StringUtils.indexOfAny(*, "")              = -1
StringUtils.indexOfAny("zzabyycdxx", "za") = 0
StringUtils.indexOfAny("zzabyycdxx", "by") = 3
StringUtils.indexOfAny("aba","z")          = -1

Parameters:: cs - the CharSequence to check, may be null; searchChars - the chars to search for, may be null

containsAny

 static boolean containsAny(CharSequence cs, Array<char> searchChars)

Checks if the CharSequence contains any character in the givenset of characters.

A {@code null} CharSequence will return {@code false}.A {@code null} or zero length search array will return {@code false}.

StringUtils.containsAny(null, *)                = false
StringUtils.containsAny("", *)                  = false
StringUtils.containsAny(*, null)                = false
StringUtils.containsAny(*, [])                  = false
StringUtils.containsAny("zzabyycdxx",['z','a']) = true
StringUtils.containsAny("zzabyycdxx",['b','y']) = true
StringUtils.containsAny("aba", ['z'])           = false

Parameters:: cs - the CharSequence to check, may be null; searchChars - the chars to search for, may be null

containsAny

 static boolean containsAny(CharSequence cs, CharSequence searchChars)

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

A {@code null} CharSequence will return {@code false}. A {@code null} search CharSequence will return {@code false}.

StringUtils.containsAny(null, *)            = false
StringUtils.containsAny("", *)              = false
StringUtils.containsAny(*, null)            = false
StringUtils.containsAny(*, "")              = false
StringUtils.containsAny("zzabyycdxx", "za") = true
StringUtils.containsAny("zzabyycdxx", "by") = true
StringUtils.containsAny("aba","z")          = false

Parameters:: cs - the CharSequence to check, may be null; searchChars - the chars to search for, may be null

indexOfAnyBut

 static int indexOfAnyBut(CharSequence cs, Array<char> searchChars)

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

A {@code null} CharSequence will return {@code -1}.A {@code null} or zero length search array will return {@code -1}.

StringUtils.indexOfAnyBut(null, *)                              = -1
StringUtils.indexOfAnyBut("", *)                                = -1
StringUtils.indexOfAnyBut(*, null)                              = -1
StringUtils.indexOfAnyBut(*, [])                                = -1
StringUtils.indexOfAnyBut("zzabyycdxx", new char[] {'z', 'a'} ) = 3
StringUtils.indexOfAnyBut("aba", new char[] {'z'} )             = 0
StringUtils.indexOfAnyBut("aba", new char[] {'a', 'b'} )        = -1

Parameters:: cs - the CharSequence to check, may be null; searchChars - the chars to search for, may be null

indexOfAnyBut

 static int indexOfAnyBut(CharSequence seq, CharSequence searchChars)

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

A {@code null} CharSequence will return {@code -1}.A {@code null} or empty search string will return {@code -1}.

StringUtils.indexOfAnyBut(null, *)            = -1
StringUtils.indexOfAnyBut("", *)              = -1
StringUtils.indexOfAnyBut(*, null)            = -1
StringUtils.indexOfAnyBut(*, "")              = -1
StringUtils.indexOfAnyBut("zzabyycdxx", "za") = 3
StringUtils.indexOfAnyBut("zzabyycdxx", "")   = -1
StringUtils.indexOfAnyBut("aba","ab")         = -1

Parameters:: seq - the CharSequence to check, may be null; searchChars - the chars to search for, may be null

containsOnly

 static boolean containsOnly(CharSequence cs, Array<char> valid)

Checks if the CharSequence contains only certain characters.

A {@code null} CharSequence will return {@code false}.A {@code null} valid character array will return {@code false}.An empty CharSequence (length()=0) always returns {@code true}.

StringUtils.containsOnly(null, *)       = false
StringUtils.containsOnly(*, null)       = false
StringUtils.containsOnly("", *)         = true
StringUtils.containsOnly("ab", '')      = false
StringUtils.containsOnly("abab", 'abc') = true
StringUtils.containsOnly("ab1", 'abc')  = false
StringUtils.containsOnly("abz", 'abc')  = false

Parameters:: cs - the String to check, may be null; valid - an array of valid chars, may be null

containsOnly

 static boolean containsOnly(CharSequence cs, String validChars)

Checks if the CharSequence contains only certain characters.

A {@code null} CharSequence will return {@code false}.A {@code null} valid character String will return {@code false}.An empty String (length()=0) always returns {@code true}.

StringUtils.containsOnly(null, *)       = false
StringUtils.containsOnly(*, null)       = false
StringUtils.containsOnly("", *)         = true
StringUtils.containsOnly("ab", "")      = false
StringUtils.containsOnly("abab", "abc") = true
StringUtils.containsOnly("ab1", "abc")  = false
StringUtils.containsOnly("abz", "abc")  = false

Parameters:: cs - the CharSequence to check, may be null; validChars - a String of valid chars, may be null

containsNone

 static boolean containsNone(CharSequence cs, Array<char> searchChars)

Checks that the CharSequence does not contain certain characters.

A {@code null} CharSequence will return {@code true}.A {@code null} invalid character array will return {@code true}.An empty CharSequence (length()=0) always returns true.

StringUtils.containsNone(null, *)       = true
StringUtils.containsNone(*, null)       = true
StringUtils.containsNone("", *)         = true
StringUtils.containsNone("ab", '')      = true
StringUtils.containsNone("abab", 'xyz') = true
StringUtils.containsNone("ab1", 'xyz')  = true
StringUtils.containsNone("abz", 'xyz')  = false

Parameters:: cs - the CharSequence to check, may be null; searchChars - an array of invalid chars, may be null

containsNone

 static boolean containsNone(CharSequence cs, String invalidChars)

Checks that the CharSequence does not contain certain characters.

A {@code null} CharSequence will return {@code true}.A {@code null} invalid character array will return {@code true}.An empty String ("") always returns true.

StringUtils.containsNone(null, *)       = true
StringUtils.containsNone(*, null)       = true
StringUtils.containsNone("", *)         = true
StringUtils.containsNone("ab", "")      = true
StringUtils.containsNone("abab", "xyz") = true
StringUtils.containsNone("ab1", "xyz")  = true
StringUtils.containsNone("abz", "xyz")  = false

Parameters:: cs - the CharSequence to check, may be null; invalidChars - a String of invalid chars, may be null

indexOfAny

 static int indexOfAny(CharSequence str, Array<CharSequence> searchStrs)

Find the first index of any of a set of potential substrings.

A {@code null} CharSequence will return {@code -1}.A {@code null} or zero length search array will return {@code -1}.A {@code null} search array entry will be ignored, but a searcharray containing "" will return {@code 0} if {@code str} is notnull. This method uses indexOf if possible.

StringUtils.indexOfAny(null, *)                     = -1
StringUtils.indexOfAny(*, null)                     = -1
StringUtils.indexOfAny(*, [])                       = -1
StringUtils.indexOfAny("zzabyycdxx", ["ab","cd"])   = 2
StringUtils.indexOfAny("zzabyycdxx", ["cd","ab"])   = 2
StringUtils.indexOfAny("zzabyycdxx", ["mn","op"])   = -1
StringUtils.indexOfAny("zzabyycdxx", ["zab","aby"]) = 1
StringUtils.indexOfAny("zzabyycdxx", [""])          = 0
StringUtils.indexOfAny("", [""])                    = 0
StringUtils.indexOfAny("", ["a"])                   = -1

Parameters:: str - the CharSequence to check, may be null; searchStrs - the CharSequences to search for, may be null

lastIndexOfAny

 static int lastIndexOfAny(CharSequence str, Array<CharSequence> searchStrs)

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

A {@code null} CharSequence will return {@code -1}.A {@code null} search array will return {@code -1}.A {@code null} or zero length search array entry will be ignored,but a search array containing "" will return the length of {@code str} if {@code str} is not null. This method uses indexOf if possible

StringUtils.lastIndexOfAny(null, *)                   = -1
StringUtils.lastIndexOfAny(*, null)                   = -1
StringUtils.lastIndexOfAny(*, [])                     = -1
StringUtils.lastIndexOfAny(*, [null])                 = -1
StringUtils.lastIndexOfAny("zzabyycdxx", ["ab","cd"]) = 6
StringUtils.lastIndexOfAny("zzabyycdxx", ["cd","ab"]) = 6
StringUtils.lastIndexOfAny("zzabyycdxx", ["mn","op"]) = -1
StringUtils.lastIndexOfAny("zzabyycdxx", ["mn","op"]) = -1
StringUtils.lastIndexOfAny("zzabyycdxx", ["mn",""])   = 10

Parameters:: str - the CharSequence to check, may be null; searchStrs - the CharSequences to search for, may be null

substring
```
 static String substring(String str, int start)
```
Gets a substring from the specified String avoiding exceptions.
A negative start position can be used to start {@code n} characters from the end of the String.
A {@code null} String will return {@code null}.An empty ("") String will return "".
```
StringUtils.substring(null, *)   = null
StringUtils.substring("", *)     = ""
StringUtils.substring("abc", 0)  = "abc"
StringUtils.substring("abc", 2)  = "c"
StringUtils.substring("abc", 4)  = ""
StringUtils.substring("abc", -2) = "bc"
StringUtils.substring("abc", -4) = "abc"
```
Parameters:

str - the String to get the substring from, may be null

start - the position to start from, negative meanscount back from the end of the String by this many characters

substring
```
 static String substring(String str, int start, int end)
```
Gets a substring from the specified String avoiding exceptions.
A negative start position can be used to start/end {@code n} characters from the end of the String.
The returned substring starts with the character in the {@code start} position and ends before the {@code end} position. All position counting iszero-based -- i.e., to start at the beginning of the string use {@code start = 0}. Negative start and end positions can be used tospecify offsets relative to the end of the String.
If {@code start} is not strictly to the left of {@code end}, ""is returned.
```
StringUtils.substring(null, *, *)    = null
StringUtils.substring("", * ,  *)    = "";
StringUtils.substring("abc", 0, 2)   = "ab"
StringUtils.substring("abc", 2, 0)   = ""
StringUtils.substring("abc", 2, 4)   = "c"
StringUtils.substring("abc", 4, 6)   = ""
StringUtils.substring("abc", 2, 2)   = ""
StringUtils.substring("abc", -2, -1) = "b"
StringUtils.substring("abc", -4, 2)  = "ab"
```
Parameters:

str - the String to get the substring from, may be null

start - the position to start from, negative meanscount back from the end of the String by this many characters

end - the position to end at (exclusive), negative meanscount back from the end of the String by this many characters

left
```
 static String left(String str, int len)
```
Gets the leftmost {@code len} characters of a String.
If {@code len} characters are not available, or theString is {@code null}, the String will be returned withoutan exception. An empty String is returned if len is negative.
```
StringUtils.left(null, *)    = null
StringUtils.left(*, -ve)     = ""
StringUtils.left("", *)      = ""
StringUtils.left("abc", 0)   = ""
StringUtils.left("abc", 2)   = "ab"
StringUtils.left("abc", 4)   = "abc"
```
Parameters:

str - the String to get the leftmost characters from, may be null

len - the length of the required String

right
```
 static String right(String str, int len)
```
Gets the rightmost {@code len} characters of a String.
If {@code len} characters are not available, or the Stringis {@code null}, the String will be returned without anan exception. An empty String is returned if len is negative.
```
StringUtils.right(null, *)    = null
StringUtils.right(*, -ve)     = ""
StringUtils.right("", *)      = ""
StringUtils.right("abc", 0)   = ""
StringUtils.right("abc", 2)   = "bc"
StringUtils.right("abc", 4)   = "abc"
```
Parameters:

str - the String to get the rightmost characters from, may be null

len - the length of the required String

mid
```
 static String mid(String str, int pos, int len)
```
Gets {@code len} characters from the middle of a String.
If {@code len} characters are not available, the remainderof the String will be returned without an exception. If theString is {@code null}, {@code null} will be returned.An empty String is returned if len is negative or exceeds thelength of {@code str}.
```
StringUtils.mid(null, *, *)    = null
StringUtils.mid(*, *, -ve)     = ""
StringUtils.mid("", 0, *)      = ""
StringUtils.mid("abc", 0, 2)   = "ab"
StringUtils.mid("abc", 0, 4)   = "abc"
StringUtils.mid("abc", 2, 4)   = "c"
StringUtils.mid("abc", 4, 2)   = ""
StringUtils.mid("abc", -2, 2)  = "ab"
```
Parameters:

str - the String to get the characters from, may be null

pos - the position to start from, negative treated as zero

len - the length of the required String

substringBefore

 static String substringBefore(String str, String separator)

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

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

If nothing is found, the string input is returned.

StringUtils.substringBefore(null, *)      = null
StringUtils.substringBefore("", *)        = ""
StringUtils.substringBefore("abc", "a")   = ""
StringUtils.substringBefore("abcba", "b") = "a"
StringUtils.substringBefore("abc", "c")   = "ab"
StringUtils.substringBefore("abc", "d")   = "abc"
StringUtils.substringBefore("abc", "")    = ""
StringUtils.substringBefore("abc", null)  = "abc"

Parameters:: str - the String to get a substring from, may be null; separator - the String to search for, may be null

substringAfter
```
 static String substringAfter(String str, String separator)
```
Gets the substring after the first occurrence of a separator.The separator is not returned.
A {@code null} string input will return {@code null}.An empty ("") string input will return the empty string.A {@code null} separator will return the empty string if theinput string is not {@code null}.
If nothing is found, the empty string is returned.
```
StringUtils.substringAfter(null, *)      = null
StringUtils.substringAfter("", *)        = ""
StringUtils.substringAfter(*, null)      = ""
StringUtils.substringAfter("abc", "a")   = "bc"
StringUtils.substringAfter("abcba", "b") = "cba"
StringUtils.substringAfter("abc", "c")   = ""
StringUtils.substringAfter("abc", "d")   = ""
StringUtils.substringAfter("abc", "")    = "abc"
```
Parameters:

str - the String to get a substring from, may be null

separator - the String to search for, may be null

substringBeforeLast

 static String substringBeforeLast(String str, String separator)

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

A {@code null} string input will return {@code 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.

StringUtils.substringBeforeLast(null, *)      = null
StringUtils.substringBeforeLast("", *)        = ""
StringUtils.substringBeforeLast("abcba", "b") = "abc"
StringUtils.substringBeforeLast("abc", "c")   = "ab"
StringUtils.substringBeforeLast("a", "a")     = ""
StringUtils.substringBeforeLast("a", "z")     = "a"
StringUtils.substringBeforeLast("a", null)    = "a"
StringUtils.substringBeforeLast("a", "")      = "a"

Parameters:: str - the String to get a substring from, may be null; separator - the String to search for, may be null

substringAfterLast

 static String substringAfterLast(String str, String separator)

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

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

If nothing is found, the empty string is returned.

StringUtils.substringAfterLast(null, *)      = null
StringUtils.substringAfterLast("", *)        = ""
StringUtils.substringAfterLast(*, "")        = ""
StringUtils.substringAfterLast(*, null)      = ""
StringUtils.substringAfterLast("abc", "a")   = "bc"
StringUtils.substringAfterLast("abcba", "b") = "a"
StringUtils.substringAfterLast("abc", "c")   = ""
StringUtils.substringAfterLast("a", "a")     = ""
StringUtils.substringAfterLast("a", "z")     = ""

Parameters:: str - the String to get a substring from, may be null; separator - the String to search for, may be null

substringBetween

 static String substringBetween(String str, String tag)

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

A {@code null} input String returns {@code null}.A {@code null} tag returns {@code null}.

StringUtils.substringBetween(null, *)            = null
StringUtils.substringBetween("", "")             = ""
StringUtils.substringBetween("", "tag")          = null
StringUtils.substringBetween("tagabctag", null)  = null
StringUtils.substringBetween("tagabctag", "")    = ""
StringUtils.substringBetween("tagabctag", "tag") = "abc"

Parameters:: str - the String containing the substring, may be null; tag - the String before and after the substring, may be null

substringBetween

 static String substringBetween(String str, String open, String close)

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

A {@code null} input String returns {@code null}.A {@code null} open/close returns {@code null} (no match).An empty ("") open and close returns an empty string.

StringUtils.substringBetween("wx[b]yz", "[", "]") = "b"
StringUtils.substringBetween(null, *, *)          = null
StringUtils.substringBetween(*, null, *)          = null
StringUtils.substringBetween(*, *, null)          = null
StringUtils.substringBetween("", "", "")          = ""
StringUtils.substringBetween("", "", "]")         = null
StringUtils.substringBetween("", "[", "]")        = null
StringUtils.substringBetween("yabcz", "", "")     = ""
StringUtils.substringBetween("yabcz", "y", "z")   = "abc"
StringUtils.substringBetween("yabczyabcz", "y", "z")   = "abc"

Parameters:: str - the String containing the substring, may be null; open - the String before the substring, may be null; close - the String after the substring, may be null

substringsBetween
```
 static Array<String> substringsBetween(String str, String open, String close)
```
Searches a String for substrings delimited by a start and end tag,returning all matching substrings in an array.
A {@code null} input String returns {@code null}.A {@code null} open/close returns {@code null} (no match).An empty ("") open/close returns {@code null} (no match).
```
StringUtils.substringsBetween("[a][b][c]", "[", "]") = ["a","b","c"]
StringUtils.substringsBetween(null, *, *)            = null
StringUtils.substringsBetween(*, null, *)            = null
StringUtils.substringsBetween(*, *, null)            = null
StringUtils.substringsBetween("", "[", "]")          = []
```
Parameters:

str - the String containing the substrings, null returns null, empty returns empty

open - the String identifying the start of the substring, empty returns null

close - the String identifying the end of the substring, empty returns null

split
```
 static Array<String> split(String str)
```
Splits the provided text into an array, using whitespace as theseparator.Whitespace is defined by isWhitespace.
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 {@code null} input String returns {@code null}.
```
StringUtils.split(null)       = null
StringUtils.split("")         = []
StringUtils.split("abc def")  = ["abc", "def"]
StringUtils.split("abc  def") = ["abc", "def"]
StringUtils.split(" abc ")    = ["abc"]
```
Parameters:

str - the String to parse, may be null

split
```
 static Array<String> split(String str, char separatorChar)
```
Splits the provided text into an array, separator 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 {@code null} input String returns {@code null}.
```
StringUtils.split(null, *)         = null
StringUtils.split("", *)           = []
StringUtils.split("a.b.c", '.')    = ["a", "b", "c"]
StringUtils.split("a..b.c", '.')   = ["a", "b", "c"]
StringUtils.split("a:b:c", '.')    = ["a:b:c"]
StringUtils.split("a b c", ' ')    = ["a", "b", "c"]
```
Parameters:

str - the String to parse, may be null

separatorChar - the character used as the delimiter

split
```
 static Array<String> split(String str, String separatorChars)
```
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 {@code null} input String returns {@code null}.A {@code null} separatorChars splits on whitespace.
```
StringUtils.split(null, *)         = null
StringUtils.split("", *)           = []
StringUtils.split("abc def", null) = ["abc", "def"]
StringUtils.split("abc def", " ")  = ["abc", "def"]
StringUtils.split("abc  def", " ") = ["abc", "def"]
StringUtils.split("ab:cd:ef", ":") = ["ab", "cd", "ef"]
```
Parameters:

str - the String to parse, may be null

separatorChars - the characters used as the delimiters,{@code null} splits on whitespace

split
```
 static Array<String> split(String str, String separatorChars, int max)
```
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 {@code null} input String returns {@code null}.A {@code null} separatorChars splits on whitespace.
If more than {@code max} delimited substrings are found, the lastreturned string includes all characters after the first {@code max - 1} returned strings (including separator characters).
```
StringUtils.split(null, *, *)            = null
StringUtils.split("", *, *)              = []
StringUtils.split("ab de fg", null, 0)   = ["ab", "cd", "ef"]
StringUtils.split("ab   de fg", null, 0) = ["ab", "cd", "ef"]
StringUtils.split("ab:cd:ef", ":", 0)    = ["ab", "cd", "ef"]
StringUtils.split("ab:cd:ef", ":", 2)    = ["ab", "cd:ef"]
```
Parameters:

str - the String to parse, may be null

separatorChars - the characters used as the delimiters,{@code null} splits on whitespace

max - the maximum number of elements to include in thearray.

splitByWholeSeparator

 static Array<String> splitByWholeSeparator(String str, String separator)

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

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

A {@code null} input String returns {@code null}.A {@code null} separator splits on whitespace.

StringUtils.splitByWholeSeparator(null, *)               = null
StringUtils.splitByWholeSeparator("", *)                 = []
StringUtils.splitByWholeSeparator("ab de fg", null)      = ["ab", "de", "fg"]
StringUtils.splitByWholeSeparator("ab   de fg", null)    = ["ab", "de", "fg"]
StringUtils.splitByWholeSeparator("ab:cd:ef", ":")       = ["ab", "cd", "ef"]
StringUtils.splitByWholeSeparator("ab-!-cd-!-ef", "-!-") = ["ab", "cd", "ef"]

Parameters:: str - the String to parse, may be null; separator - String containing the String to be used as a delimiter,{@code null} splits on whitespace

splitByWholeSeparator

 static Array<String> splitByWholeSeparator(String str, String separator, int max)

Splits the provided text into an array, separator string specified.Returns a maximum of {@code max} substrings.

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

A {@code null} input String returns {@code null}.A {@code null} separator splits on whitespace.

StringUtils.splitByWholeSeparator(null, *, *)               = null
StringUtils.splitByWholeSeparator("", *, *)                 = []
StringUtils.splitByWholeSeparator("ab de fg", null, 0)      = ["ab", "de", "fg"]
StringUtils.splitByWholeSeparator("ab   de fg", null, 0)    = ["ab", "de", "fg"]
StringUtils.splitByWholeSeparator("ab:cd:ef", ":", 2)       = ["ab", "cd:ef"]
StringUtils.splitByWholeSeparator("ab-!-cd-!-ef", "-!-", 5) = ["ab", "cd", "ef"]
StringUtils.splitByWholeSeparator("ab-!-cd-!-ef", "-!-", 2) = ["ab", "cd-!-ef"]

Parameters:: str - the String to parse, may be null; separator - String containing the String to be used as a delimiter,{@code null} splits on whitespace; max - the maximum number of elements to include in the returnedarray.

splitByWholeSeparatorPreserveAllTokens

 static Array<String> splitByWholeSeparatorPreserveAllTokens(String str, String separator)

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 {@code null} input String returns {@code null}.A {@code null} separator splits on whitespace.

StringUtils.splitByWholeSeparatorPreserveAllTokens(null, *)               = null
StringUtils.splitByWholeSeparatorPreserveAllTokens("", *)                 = []
StringUtils.splitByWholeSeparatorPreserveAllTokens("ab de fg", null)      = ["ab", "de", "fg"]
StringUtils.splitByWholeSeparatorPreserveAllTokens("ab   de fg", null)    = ["ab", "", "", "de", "fg"]
StringUtils.splitByWholeSeparatorPreserveAllTokens("ab:cd:ef", ":")       = ["ab", "cd", "ef"]
StringUtils.splitByWholeSeparatorPreserveAllTokens("ab-!-cd-!-ef", "-!-") = ["ab", "cd", "ef"]

Parameters:: str - the String to parse, may be null; separator - String containing the String to be used as a delimiter,{@code null} splits on whitespace

splitByWholeSeparatorPreserveAllTokens

 static Array<String> splitByWholeSeparatorPreserveAllTokens(String str, String separator, int max)

Splits the provided text into an array, separator string specified.Returns a maximum of {@code 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 {@code null} input String returns {@code null}.A {@code null} separator splits on whitespace.

StringUtils.splitByWholeSeparatorPreserveAllTokens(null, *, *)               = null
StringUtils.splitByWholeSeparatorPreserveAllTokens("", *, *)                 = []
StringUtils.splitByWholeSeparatorPreserveAllTokens("ab de fg", null, 0)      = ["ab", "de", "fg"]
StringUtils.splitByWholeSeparatorPreserveAllTokens("ab   de fg", null, 0)    = ["ab", "", "", "de", "fg"]
StringUtils.splitByWholeSeparatorPreserveAllTokens("ab:cd:ef", ":", 2)       = ["ab", "cd:ef"]
StringUtils.splitByWholeSeparatorPreserveAllTokens("ab-!-cd-!-ef", "-!-", 5) = ["ab", "cd", "ef"]
StringUtils.splitByWholeSeparatorPreserveAllTokens("ab-!-cd-!-ef", "-!-", 2) = ["ab", "cd-!-ef"]

Parameters:: str - the String to parse, may be null; separator - String containing the String to be used as a delimiter,{@code null} splits on whitespace; max - the maximum number of elements to include in the returnedarray.

splitPreserveAllTokens
```
 static Array<String> splitPreserveAllTokens(String str)
```
Splits the provided text into an array, using whitespace as theseparator, preserving all tokens, including empty tokens created byadjacent separators. This is an alternative to using StringTokenizer.Whitespace is defined by isWhitespace.
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 {@code null} input String returns {@code null}.
```
StringUtils.splitPreserveAllTokens(null)       = null
StringUtils.splitPreserveAllTokens("")         = []
StringUtils.splitPreserveAllTokens("abc def")  = ["abc", "def"]
StringUtils.splitPreserveAllTokens("abc  def") = ["abc", "", "def"]
StringUtils.splitPreserveAllTokens(" abc ")    = ["", "abc", ""]
```
Parameters:

str - the String to parse, may be {@code null}

splitPreserveAllTokens

 static Array<String> splitPreserveAllTokens(String str, char separatorChar)

Splits the provided text into an array, separator specified,preserving all tokens, including empty tokens created by adjacentseparators. 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 {@code null} input String returns {@code null}.

StringUtils.splitPreserveAllTokens(null, *)         = null
StringUtils.splitPreserveAllTokens("", *)           = []
StringUtils.splitPreserveAllTokens("a.b.c", '.')    = ["a", "b", "c"]
StringUtils.splitPreserveAllTokens("a..b.c", '.')   = ["a", "", "b", "c"]
StringUtils.splitPreserveAllTokens("a:b:c", '.')    = ["a:b:c"]
StringUtils.splitPreserveAllTokens("a\tb\nc", null) = ["a", "b", "c"]
StringUtils.splitPreserveAllTokens("a b c", ' ')    = ["a", "b", "c"]
StringUtils.splitPreserveAllTokens("a b c ", ' ')   = ["a", "b", "c", ""]
StringUtils.splitPreserveAllTokens("a b c  ", ' ')   = ["a", "b", "c", "", ""]
StringUtils.splitPreserveAllTokens(" a b c", ' ')   = ["", a", "b", "c"]
StringUtils.splitPreserveAllTokens("  a b c", ' ')  = ["", "", a", "b", "c"]
StringUtils.splitPreserveAllTokens(" a b c ", ' ')  = ["", a", "b", "c", ""]

Parameters:: str - the String to parse, may be {@code null}; separatorChar - the character used as the delimiter,{@code null} splits on whitespace

splitPreserveAllTokens

 static Array<String> splitPreserveAllTokens(String str, String separatorChars)

Splits the provided text into an array, separators specified,preserving all tokens, including empty tokens created by adjacentseparators. 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 {@code null} input String returns {@code null}.A {@code null} separatorChars splits on whitespace.

StringUtils.splitPreserveAllTokens(null, *)           = null
StringUtils.splitPreserveAllTokens("", *)             = []
StringUtils.splitPreserveAllTokens("abc def", null)   = ["abc", "def"]
StringUtils.splitPreserveAllTokens("abc def", " ")    = ["abc", "def"]
StringUtils.splitPreserveAllTokens("abc  def", " ")   = ["abc", "", def"]
StringUtils.splitPreserveAllTokens("ab:cd:ef", ":")   = ["ab", "cd", "ef"]
StringUtils.splitPreserveAllTokens("ab:cd:ef:", ":")  = ["ab", "cd", "ef", ""]
StringUtils.splitPreserveAllTokens("ab:cd:ef::", ":") = ["ab", "cd", "ef", "", ""]
StringUtils.splitPreserveAllTokens("ab::cd:ef", ":")  = ["ab", "", cd", "ef"]
StringUtils.splitPreserveAllTokens(":cd:ef", ":")     = ["", cd", "ef"]
StringUtils.splitPreserveAllTokens("::cd:ef", ":")    = ["", "", cd", "ef"]
StringUtils.splitPreserveAllTokens(":cd:ef:", ":")    = ["", cd", "ef", ""]

Parameters:: str - the String to parse, may be {@code null}; separatorChars - the characters used as the delimiters,{@code null} splits on whitespace

splitPreserveAllTokens
```
 static Array<String> splitPreserveAllTokens(String str, String separatorChars, int max)
```
Splits the provided text into an array with a maximum length,separators specified, preserving all tokens, including empty tokenscreated 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 {@code null} input String returns {@code null}.A {@code null} separatorChars splits on whitespace.
If more than {@code max} delimited substrings are found, the lastreturned string includes all characters after the first {@code max - 1} returned strings (including separator characters).
```
StringUtils.splitPreserveAllTokens(null, *, *)            = null
StringUtils.splitPreserveAllTokens("", *, *)              = []
StringUtils.splitPreserveAllTokens("ab de fg", null, 0)   = ["ab", "cd", "ef"]
StringUtils.splitPreserveAllTokens("ab   de fg", null, 0) = ["ab", "cd", "ef"]
StringUtils.splitPreserveAllTokens("ab:cd:ef", ":", 0)    = ["ab", "cd", "ef"]
StringUtils.splitPreserveAllTokens("ab:cd:ef", ":", 2)    = ["ab", "cd:ef"]
StringUtils.splitPreserveAllTokens("ab   de fg", null, 2) = ["ab", "  de fg"]
StringUtils.splitPreserveAllTokens("ab   de fg", null, 3) = ["ab", "", " de fg"]
StringUtils.splitPreserveAllTokens("ab   de fg", null, 4) = ["ab", "", "", "de fg"]
```
Parameters:

str - the String to parse, may be {@code null}

separatorChars - the characters used as the delimiters,{@code null} splits on whitespace

max - the maximum number of elements to include in thearray.

splitByCharacterType

 static Array<String> splitByCharacterType(String str)

Splits a String by Character type as returned by {@code java.lang.Character.getType(char)}. Groups of contiguouscharacters of the same type are returned as complete tokens.

StringUtils.splitByCharacterType(null)         = null
StringUtils.splitByCharacterType("")           = []
StringUtils.splitByCharacterType("ab de fg")   = ["ab", " ", "de", " ", "fg"]
StringUtils.splitByCharacterType("ab   de fg") = ["ab", "   ", "de", " ", "fg"]
StringUtils.splitByCharacterType("ab:cd:ef")   = ["ab", ":", "cd", ":", "ef"]
StringUtils.splitByCharacterType("number5")    = ["number", "5"]
StringUtils.splitByCharacterType("fooBar")     = ["foo", "B", "ar"]
StringUtils.splitByCharacterType("foo200Bar")  = ["foo", "200", "B", "ar"]
StringUtils.splitByCharacterType("ASFRules")   = ["ASFR", "ules"]

Parameters:: str - the String to split, may be {@code null}

splitByCharacterTypeCamelCase

 static Array<String> splitByCharacterTypeCamelCase(String str)

Splits a String by Character type as returned by {@code java.lang.Character.getType(char)}. Groups of contiguouscharacters of the same type are returned as complete tokens, with thefollowing exception: the character of type {@code Character.UPPERCASE_LETTER}, if any, immediatelypreceding a token of type {@code Character.LOWERCASE_LETTER} will belong to the following token rather than to the preceding, if any, {@code Character.UPPERCASE_LETTER} token.

StringUtils.splitByCharacterTypeCamelCase(null)         = null
StringUtils.splitByCharacterTypeCamelCase("")           = []
StringUtils.splitByCharacterTypeCamelCase("ab de fg")   = ["ab", " ", "de", " ", "fg"]
StringUtils.splitByCharacterTypeCamelCase("ab   de fg") = ["ab", "   ", "de", " ", "fg"]
StringUtils.splitByCharacterTypeCamelCase("ab:cd:ef")   = ["ab", ":", "cd", ":", "ef"]
StringUtils.splitByCharacterTypeCamelCase("number5")    = ["number", "5"]
StringUtils.splitByCharacterTypeCamelCase("fooBar")     = ["foo", "Bar"]
StringUtils.splitByCharacterTypeCamelCase("foo200Bar")  = ["foo", "200", "Bar"]
StringUtils.splitByCharacterTypeCamelCase("ASFRules")   = ["ASF", "Rules"]

Parameters:: str - the String to split, may be {@code null}

join
```
 static <T> String join(Array<T> elements)
```
Joins the elements of the provided array into a single Stringcontaining the provided list of elements.
No separator is added to the joined String.Null objects or empty strings within the array are represented byempty strings.
```
StringUtils.join(null)            = null
StringUtils.join([])              = ""
StringUtils.join([null])          = ""
StringUtils.join(["a", "b", "c"]) = "abc"
StringUtils.join([null, "", "a"]) = "a"
```
Parameters:

elements - the values to join together, may be null

join

 static String join(Array<Object> array, char separator)

Joins the elements of the provided array into a single Stringcontaining the provided list of elements.

No delimiter is added before or after the list.Null objects or empty strings within the array are represented byempty strings.

StringUtils.join(null, *)               = null
StringUtils.join([], *)                 = ""
StringUtils.join([null], *)             = ""
StringUtils.join(["a", "b", "c"], ';')  = "a;b;c"
StringUtils.join(["a", "b", "c"], null) = "abc"
StringUtils.join([null, "", "a"], ';')  = ";;a"

Parameters:: array - the array of values to join together, may be null; separator - the separator character to use

join
```
 static String join(Array<Object> array, char separator, int startIndex, int endIndex)
```
Joins the elements of the provided array into a single Stringcontaining the provided list of elements.
No delimiter is added before or after the list.Null objects or empty strings within the array are represented byempty strings.
```
StringUtils.join(null, *)               = null
StringUtils.join([], *)                 = ""
StringUtils.join([null], *)             = ""
StringUtils.join(["a", "b", "c"], ';')  = "a;b;c"
StringUtils.join(["a", "b", "c"], null) = "abc"
StringUtils.join([null, "", "a"], ';')  = ";;a"
```
Parameters:

array - the array of values to join together, may be null

separator - the separator character to use

startIndex - the first index to start joining from.

endIndex - the index to stop joining from (exclusive).

join
```
 static String join(Array<Object> array, String separator)
```
Joins the elements of the provided array into a single Stringcontaining the provided list of elements.
No delimiter is added before or after the list.A {@code null} separator is the same as an empty String ("").Null objects or empty strings within the array are represented byempty strings.
```
StringUtils.join(null, *)                = null
StringUtils.join([], *)                  = ""
StringUtils.join([null], *)              = ""
StringUtils.join(["a", "b", "c"], "--")  = "a--b--c"
StringUtils.join(["a", "b", "c"], null)  = "abc"
StringUtils.join(["a", "b", "c"], "")    = "abc"
StringUtils.join([null, "", "a"], ',')   = ",,a"
```
Parameters:

array - the array of values to join together, may be null

separator - the separator character to use, null treated as ""

join
```
 static String join(Array<Object> array, String separator, int startIndex, int endIndex)
```
Joins the elements of the provided array into a single Stringcontaining the provided list of elements.
No delimiter is added before or after the list.A {@code null} separator is the same as an empty String ("").Null objects or empty strings within the array are represented byempty strings.
```
StringUtils.join(null, *)                = null
StringUtils.join([], *)                  = ""
StringUtils.join([null], *)              = ""
StringUtils.join(["a", "b", "c"], "--")  = "a--b--c"
StringUtils.join(["a", "b", "c"], null)  = "abc"
StringUtils.join(["a", "b", "c"], "")    = "abc"
StringUtils.join([null, "", "a"], ',')   = ",,a"
```
Parameters:

array - the array of values to join together, may be null

separator - the separator character to use, null treated as ""

startIndex - the first index to start joining from.

endIndex - the index to stop joining from (exclusive).

join
```
 static String join(Iterator<out Object> iterator, char separator)
```
Joins the elements of the provided {@code Iterator} intoa single String containing the provided elements.
No delimiter is added before or after the list. Null objects or emptystrings within the iteration are represented by empty strings.
See the examples here: join.

Parameters:

iterator - the {@code Iterator} of values to join together, may be null

separator - the separator character to use

join
```
 static String join(Iterator<out Object> iterator, String separator)
```
Joins the elements of the provided {@code Iterator} intoa single String containing the provided elements.
No delimiter is added before or after the list.A {@code null} separator is the same as an empty String ("").
See the examples here: join.

Parameters:

iterator - the {@code Iterator} of values to join together, may be null

separator - the separator character to use, null treated as ""

join
```
 static String join(Iterable<out Object> iterable, char separator)
```
Joins the elements of the provided {@code Iterable} intoa single String containing the provided elements.
No delimiter is added before or after the list. Null objects or emptystrings within the iteration are represented by empty strings.
See the examples here: join.

Parameters:

iterable - the {@code Iterable} providing the values to join together, may be null

separator - the separator character to use

join
```
 static String join(Iterable<out Object> iterable, String separator)
```
Joins the elements of the provided {@code Iterable} intoa single String containing the provided elements.
No delimiter is added before or after the list.A {@code null} separator is the same as an empty String ("").
See the examples here: join.

Parameters:

iterable - the {@code Iterable} providing the values to join together, may be null

separator - the separator character to use, null treated as ""

deleteWhitespace

 static String deleteWhitespace(String str)

Deletes all whitespaces from a String as defined by isWhitespace.

StringUtils.deleteWhitespace(null)         = null
StringUtils.deleteWhitespace("")           = ""
StringUtils.deleteWhitespace("abc")        = "abc"
StringUtils.deleteWhitespace("   ab  c  ") = "abc"

Parameters:: str - the String to delete whitespace from, may be null

removeStart

 static String removeStart(String str, String remove)

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

A {@code null} source string will return {@code null}.An empty ("") source string will return the empty string.A {@code null} search string will return the source string.

StringUtils.removeStart(null, *)      = null
StringUtils.removeStart("", *)        = ""
StringUtils.removeStart(*, null)      = *
StringUtils.removeStart("www.domain.com", "www.")   = "domain.com"
StringUtils.removeStart("domain.com", "www.")       = "domain.com"
StringUtils.removeStart("www.domain.com", "domain") = "www.domain.com"
StringUtils.removeStart("abc", "")    = "abc"

Parameters:: str - the source String to search, may be null; remove - the String to search for and remove, may be null

removeStartIgnoreCase

 static String removeStartIgnoreCase(String str, String remove)

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

A {@code null} source string will return {@code null}.An empty ("") source string will return the empty string.A {@code null} search string will return the source string.

StringUtils.removeStartIgnoreCase(null, *)      = null
StringUtils.removeStartIgnoreCase("", *)        = ""
StringUtils.removeStartIgnoreCase(*, null)      = *
StringUtils.removeStartIgnoreCase("www.domain.com", "www.")   = "domain.com"
StringUtils.removeStartIgnoreCase("www.domain.com", "WWW.")   = "domain.com"
StringUtils.removeStartIgnoreCase("domain.com", "www.")       = "domain.com"
StringUtils.removeStartIgnoreCase("www.domain.com", "domain") = "www.domain.com"
StringUtils.removeStartIgnoreCase("abc", "")    = "abc"

Parameters:: str - the source String to search, may be null; remove - the String to search for (case insensitive) and remove, may be null

removeEnd

 static String removeEnd(String str, String remove)

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

A {@code null} source string will return {@code null}.An empty ("") source string will return the empty string.A {@code null} search string will return the source string.

StringUtils.removeEnd(null, *)      = null
StringUtils.removeEnd("", *)        = ""
StringUtils.removeEnd(*, null)      = *
StringUtils.removeEnd("www.domain.com", ".com.")  = "www.domain.com"
StringUtils.removeEnd("www.domain.com", ".com")   = "www.domain"
StringUtils.removeEnd("www.domain.com", "domain") = "www.domain.com"
StringUtils.removeEnd("abc", "")    = "abc"

Parameters:: str - the source String to search, may be null; remove - the String to search for and remove, may be null

removeEndIgnoreCase

 static String removeEndIgnoreCase(String str, String remove)

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

A {@code null} source string will return {@code null}.An empty ("") source string will return the empty string.A {@code null} search string will return the source string.

StringUtils.removeEndIgnoreCase(null, *)      = null
StringUtils.removeEndIgnoreCase("", *)        = ""
StringUtils.removeEndIgnoreCase(*, null)      = *
StringUtils.removeEndIgnoreCase("www.domain.com", ".com.")  = "www.domain.com"
StringUtils.removeEndIgnoreCase("www.domain.com", ".com")   = "www.domain"
StringUtils.removeEndIgnoreCase("www.domain.com", "domain") = "www.domain.com"
StringUtils.removeEndIgnoreCase("abc", "")    = "abc"
StringUtils.removeEndIgnoreCase("www.domain.com", ".COM") = "www.domain")
StringUtils.removeEndIgnoreCase("www.domain.COM", ".com") = "www.domain")

Parameters:: str - the source String to search, may be null; remove - the String to search for (case insensitive) and remove, may be null

remove
```
 static String remove(String str, String remove)
```
Removes all occurrences of a substring from within the source string.
A {@code null} source string will return {@code null}.An empty ("") source string will return the empty string.A {@code null} remove string will return the source string.An empty ("") remove string will return the source string.
```
StringUtils.remove(null, *)        = null
StringUtils.remove("", *)          = ""
StringUtils.remove(*, null)        = *
StringUtils.remove(*, "")          = *
StringUtils.remove("queued", "ue") = "qd"
StringUtils.remove("queued", "zz") = "queued"
```
Parameters:

str - the source String to search, may be null

remove - the String to search for and remove, may be null

remove
```
 static String remove(String str, char remove)
```
Removes all occurrences of a character from within the source string.
A {@code null} source string will return {@code null}.An empty ("") source string will return the empty string.
```
StringUtils.remove(null, *)       = null
StringUtils.remove("", *)         = ""
StringUtils.remove("queued", 'u') = "qeed"
StringUtils.remove("queued", 'z') = "queued"
```
Parameters:

str - the source String to search, may be null

remove - the char to search for and remove, may be null

replaceOnce

 static String replaceOnce(String text, String searchString, String replacement)

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

A {@code null} reference passed to this method is a no-op.

StringUtils.replaceOnce(null, *, *)        = null
StringUtils.replaceOnce("", *, *)          = ""
StringUtils.replaceOnce("any", null, *)    = "any"
StringUtils.replaceOnce("any", *, null)    = "any"
StringUtils.replaceOnce("any", "", *)      = "any"
StringUtils.replaceOnce("aba", "a", null)  = "aba"
StringUtils.replaceOnce("aba", "a", "")    = "ba"
StringUtils.replaceOnce("aba", "a", "z")   = "zba"

Parameters:: text - text to search and replace in, may be null; searchString - the String to search for, may be null; replacement - the String to replace with, may be null

replace

 static String replace(String text, String searchString, String replacement)

Replaces all occurrences of a String within another String.

A {@code null} reference passed to this method is a no-op.

StringUtils.replace(null, *, *)        = null
StringUtils.replace("", *, *)          = ""
StringUtils.replace("any", null, *)    = "any"
StringUtils.replace("any", *, null)    = "any"
StringUtils.replace("any", "", *)      = "any"
StringUtils.replace("aba", "a", null)  = "aba"
StringUtils.replace("aba", "a", "")    = "b"
StringUtils.replace("aba", "a", "z")   = "zbz"

Parameters:: text - text to search and replace in, may be null; searchString - the String to search for, may be null; replacement - the String to replace it with, may be null

replace

 static String replace(String text, String searchString, String replacement, int max)

Replaces a String with another String inside a larger String,for the first {@code max} values of the search String.

A {@code null} reference passed to this method is a no-op.

StringUtils.replace(null, *, *, *)         = null
StringUtils.replace("", *, *, *)           = ""
StringUtils.replace("any", null, *, *)     = "any"
StringUtils.replace("any", *, null, *)     = "any"
StringUtils.replace("any", "", *, *)       = "any"
StringUtils.replace("any", *, *, 0)        = "any"
StringUtils.replace("abaa", "a", null, -1) = "abaa"
StringUtils.replace("abaa", "a", "", -1)   = "b"
StringUtils.replace("abaa", "a", "z", 0)   = "abaa"
StringUtils.replace("abaa", "a", "z", 1)   = "zbaa"
StringUtils.replace("abaa", "a", "z", 2)   = "zbza"
StringUtils.replace("abaa", "a", "z", -1)  = "zbzz"

Parameters:: text - text to search and replace in, may be null; searchString - the String to search for, may be null; replacement - the String to replace it with, may be null; max - maximum number of values to replace, or {@code -1} if no maximum

replaceEach

 static String replaceEach(String text, Array<String> searchList, Array<String> replacementList)

Replaces all occurrences of Strings within another String.

A {@code null} reference passed to this method is a no-op, or ifany "search string" or "string to replace" is null, that replace will beignored. This will not repeat. For repeating replaces, call theoverloaded method.

 StringUtils.replaceEach(null, *, *)        = null
 StringUtils.replaceEach("", *, *)          = ""
 StringUtils.replaceEach("aba", null, null) = "aba"
 StringUtils.replaceEach("aba", new String[0], null) = "aba"
 StringUtils.replaceEach("aba", null, new String[0]) = "aba"
 StringUtils.replaceEach("aba", new String[]{"a"}, null)  = "aba"
 StringUtils.replaceEach("aba", new String[]{"a"}, new String[]{""})  = "b"
 StringUtils.replaceEach("aba", new String[]{null}, new String[]{"a"})  = "aba"
 StringUtils.replaceEach("abcde", new String[]{"ab", "d"}, new String[]{"w", "t"})  = "wcte"
 (example of how it does not repeat)
 StringUtils.replaceEach("abcde", new String[]{"ab", "d"}, new String[]{"d", "t"})  = "dcte"

Parameters:: text - text to search and replace in, no-op if null; searchList - the Strings to search for, no-op if null; replacementList - the Strings to replace them with, no-op if null

replaceEachRepeatedly

 static String replaceEachRepeatedly(String text, Array<String> searchList, Array<String> replacementList)

Replaces all occurrences of Strings within another String.

A {@code null} reference passed to this method is a no-op, or ifany "search string" or "string to replace" is null, that replace will beignored.

 StringUtils.replaceEach(null, *, *, *) = null
 StringUtils.replaceEach("", *, *, *) = ""
 StringUtils.replaceEach("aba", null, null, *) = "aba"
 StringUtils.replaceEach("aba", new String[0], null, *) = "aba"
 StringUtils.replaceEach("aba", null, new String[0], *) = "aba"
 StringUtils.replaceEach("aba", new String[]{"a"}, null, *) = "aba"
 StringUtils.replaceEach("aba", new String[]{"a"}, new String[]{""}, *) = "b"
 StringUtils.replaceEach("aba", new String[]{null}, new String[]{"a"}, *) = "aba"
 StringUtils.replaceEach("abcde", new String[]{"ab", "d"}, new String[]{"w", "t"}, *) = "wcte"
 (example of how it repeats)
 StringUtils.replaceEach("abcde", new String[]{"ab", "d"}, new String[]{"d", "t"}, false) = "dcte"
 StringUtils.replaceEach("abcde", new String[]{"ab", "d"}, new String[]{"d", "t"}, true) = "tcte"
 StringUtils.replaceEach("abcde", new String[]{"ab", "d"}, new String[]{"d", "ab"}, true) = IllegalStateException
 StringUtils.replaceEach("abcde", new String[]{"ab", "d"}, new String[]{"d", "ab"}, false) = "dcabe"

Parameters:: text - text to search and replace in, no-op if null; searchList - the Strings to search for, no-op if null; replacementList - the Strings to replace them with, no-op if null

replaceChars
```
 static String replaceChars(String str, char searchChar, char replaceChar)
```
Replaces all occurrences of a character in a String with another.This is a null-safe version of replace.
A {@code null} string input returns {@code null}.An empty ("") string input returns an empty string.
```
StringUtils.replaceChars(null, *, *)        = null
StringUtils.replaceChars("", *, *)          = ""
StringUtils.replaceChars("abcba", 'b', 'y') = "aycya"
StringUtils.replaceChars("abcba", 'z', 'y') = "abcba"
```
Parameters:

str - String to replace characters in, may be null

searchChar - the character to search for, may be null

replaceChar - the character to replace, may be null

replaceChars
```
 static String replaceChars(String str, String searchChars, String replaceChars)
```
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 {@code null} string input returns {@code 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 lengthof the replace characters.If the search characters is longer, then the extra search charactersare deleted.If the search characters is shorter, then the extra replace charactersare ignored.
```
StringUtils.replaceChars(null, *, *)           = null
StringUtils.replaceChars("", *, *)             = ""
StringUtils.replaceChars("abc", null, *)       = "abc"
StringUtils.replaceChars("abc", "", *)         = "abc"
StringUtils.replaceChars("abc", "b", null)     = "ac"
StringUtils.replaceChars("abc", "b", "")       = "ac"
StringUtils.replaceChars("abcba", "bc", "yz")  = "ayzya"
StringUtils.replaceChars("abcba", "bc", "y")   = "ayya"
StringUtils.replaceChars("abcba", "bc", "yzx") = "ayzya"
```
Parameters:

str - String to replace characters in, may be null

searchChars - a set of characters to search for, may be null

replaceChars - a set of characters to replace, may be null

overlay

 static String overlay(String str, String overlay, int start, int end)

Overlays part of a String with another String.

A {@code null} string input returns {@code null}.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.

StringUtils.overlay(null, *, *, *)            = null
StringUtils.overlay("", "abc", 0, 0)          = "abc"
StringUtils.overlay("abcdef", null, 2, 4)     = "abef"
StringUtils.overlay("abcdef", "", 2, 4)       = "abef"
StringUtils.overlay("abcdef", "", 4, 2)       = "abef"
StringUtils.overlay("abcdef", "zzzz", 2, 4)   = "abzzzzef"
StringUtils.overlay("abcdef", "zzzz", 4, 2)   = "abzzzzef"
StringUtils.overlay("abcdef", "zzzz", -1, 4)  = "zzzzef"
StringUtils.overlay("abcdef", "zzzz", 2, 8)   = "abzzzz"
StringUtils.overlay("abcdef", "zzzz", -2, -3) = "zzzzabcdef"
StringUtils.overlay("abcdef", "zzzz", 8, 10)  = "abcdefzzzz"

Parameters:: str - the String to do overlaying in, may be null; overlay - the String to overlay, may be null; start - the position to start overlaying at; end - the position to stop overlaying before

chomp

 static String chomp(String str)

Removes one newline from end of a String if it's there,otherwise leave it alone. A newline is "{@code \n}","{@code \r}", or "{@code \r\n}".

NOTE: This method changed in 2.0.It now more closely matches Perl chomp.

StringUtils.chomp(null)          = null
StringUtils.chomp("")            = ""
StringUtils.chomp("abc \r")      = "abc "
StringUtils.chomp("abc\n")       = "abc"
StringUtils.chomp("abc\r\n")     = "abc"
StringUtils.chomp("abc\r\n\r\n") = "abc\r\n"
StringUtils.chomp("abc\n\r")     = "abc\n"
StringUtils.chomp("abc\n\rabc")  = "abc\n\rabc"
StringUtils.chomp("\r")          = ""
StringUtils.chomp("\n")          = ""
StringUtils.chomp("\r\n")        = ""

Parameters:: str - the String to chomp a newline from, may be null

chomp

@Deprecated() static String chomp(String str, String separator)

Removes {@code separator} from the end of {@code str} if it's there, otherwise leave it alone.

NOTE: This method changed in version 2.0.It now more closely matches Perl chomp.For the previous behavior, use substringBeforeLast.This method uses endsWith.

StringUtils.chomp(null, *)         = null
StringUtils.chomp("", *)           = ""
StringUtils.chomp("foobar", "bar") = "foo"
StringUtils.chomp("foobar", "baz") = "foobar"
StringUtils.chomp("foo", "foo")    = ""
StringUtils.chomp("foo ", "foo")   = "foo "
StringUtils.chomp(" foo", "foo")   = " "
StringUtils.chomp("foo", "foooo")  = "foo"
StringUtils.chomp("foo", "")       = "foo"
StringUtils.chomp("foo", null)     = "foo"

Parameters:: str - the String to chomp from, may be null; separator - separator String, may be null

chop

 static String chop(String str)

Remove the last character from a String.

If the String ends in {@code \r\n}, then remove bothof them.

StringUtils.chop(null)          = null
StringUtils.chop("")            = ""
StringUtils.chop("abc \r")      = "abc "
StringUtils.chop("abc\n")       = "abc"
StringUtils.chop("abc\r\n")     = "abc"
StringUtils.chop("abc")         = "ab"
StringUtils.chop("abc\nabc")    = "abc\nab"
StringUtils.chop("a")           = ""
StringUtils.chop("\r")          = ""
StringUtils.chop("\n")          = ""
StringUtils.chop("\r\n")        = ""

Parameters:: str - the String to chop last character from, may be null

repeat

 static String repeat(String str, int repeat)

Repeat a String {@code repeat} times to form anew String.

StringUtils.repeat(null, 2) = null
StringUtils.repeat("", 0)   = ""
StringUtils.repeat("", 2)   = ""
StringUtils.repeat("a", 3)  = "aaa"
StringUtils.repeat("ab", 2) = "abab"
StringUtils.repeat("a", -2) = ""

Parameters:: str - the String to repeat, may be null; repeat - number of times to repeat str, negative treated as zero

repeat

 static String repeat(String str, String separator, int repeat)

Repeat a String {@code repeat} times to form anew String, with a String separator injected each time.

StringUtils.repeat(null, null, 2) = null
StringUtils.repeat(null, "x", 2)  = null
StringUtils.repeat("", null, 0)   = ""
StringUtils.repeat("", "", 2)     = ""
StringUtils.repeat("", "x", 3)    = "xxx"
StringUtils.repeat("?", ", ", 3)  = "?, ?, ?"

Parameters:: str - the String to repeat, may be null; separator - the String to inject, may be null; repeat - number of times to repeat str, negative treated as zero

repeat
```
 static String repeat(char ch, int repeat)
```
Returns padding using the specified delimiter repeatedto a given length.
```
StringUtils.repeat(0, 'e')  = ""
StringUtils.repeat(3, 'e')  = "eee"
StringUtils.repeat(-2, 'e') = ""
```
Note: this method doesn't not support padding withUnicode Supplementary Charactersas they require a pair of {@code char}s to be represented.If you are needing to support full I18N of your applicationsconsider using repeat instead.
Parameters:

ch - character to repeat

repeat - number of times to repeat char, negative treated as zero

rightPad

 static String rightPad(String str, int size)

Right pad a String with spaces (' ').

The String is padded to the size of {@code size}.

StringUtils.rightPad(null, *)   = null
StringUtils.rightPad("", 3)     = "   "
StringUtils.rightPad("bat", 3)  = "bat"
StringUtils.rightPad("bat", 5)  = "bat  "
StringUtils.rightPad("bat", 1)  = "bat"
StringUtils.rightPad("bat", -1) = "bat"

Parameters:: str - the String to pad out, may be null; size - the size to pad to

rightPad

 static String rightPad(String str, int size, char padChar)

Right pad a String with a specified character.

The String is padded to the size of {@code size}.

StringUtils.rightPad(null, *, *)     = null
StringUtils.rightPad("", 3, 'z')     = "zzz"
StringUtils.rightPad("bat", 3, 'z')  = "bat"
StringUtils.rightPad("bat", 5, 'z')  = "batzz"
StringUtils.rightPad("bat", 1, 'z')  = "bat"
StringUtils.rightPad("bat", -1, 'z') = "bat"

Parameters:: str - the String to pad out, may be null; size - the size to pad to; padChar - the character to pad with

rightPad

 static String rightPad(String str, int size, String padStr)

Right pad a String with a specified String.

The String is padded to the size of {@code size}.

StringUtils.rightPad(null, *, *)      = null
StringUtils.rightPad("", 3, "z")      = "zzz"
StringUtils.rightPad("bat", 3, "yz")  = "bat"
StringUtils.rightPad("bat", 5, "yz")  = "batyz"
StringUtils.rightPad("bat", 8, "yz")  = "batyzyzy"
StringUtils.rightPad("bat", 1, "yz")  = "bat"
StringUtils.rightPad("bat", -1, "yz") = "bat"
StringUtils.rightPad("bat", 5, null)  = "bat  "
StringUtils.rightPad("bat", 5, "")    = "bat  "

Parameters:: str - the String to pad out, may be null; size - the size to pad to; padStr - the String to pad with, null or empty treated as single space

leftPad

 static String leftPad(String str, int size)

Left pad a String with spaces (' ').

The String is padded to the size of {@code size}.

StringUtils.leftPad(null, *)   = null
StringUtils.leftPad("", 3)     = "   "
StringUtils.leftPad("bat", 3)  = "bat"
StringUtils.leftPad("bat", 5)  = "  bat"
StringUtils.leftPad("bat", 1)  = "bat"
StringUtils.leftPad("bat", -1) = "bat"

Parameters:: str - the String to pad out, may be null; size - the size to pad to

leftPad

 static String leftPad(String str, int size, char padChar)

Left pad a String with a specified character.

Pad to a size of {@code size}.

StringUtils.leftPad(null, *, *)     = null
StringUtils.leftPad("", 3, 'z')     = "zzz"
StringUtils.leftPad("bat", 3, 'z')  = "bat"
StringUtils.leftPad("bat", 5, 'z')  = "zzbat"
StringUtils.leftPad("bat", 1, 'z')  = "bat"
StringUtils.leftPad("bat", -1, 'z') = "bat"

Parameters:: str - the String to pad out, may be null; size - the size to pad to; padChar - the character to pad with

leftPad

 static String leftPad(String str, int size, String padStr)

Left pad a String with a specified String.

Pad to a size of {@code size}.

StringUtils.leftPad(null, *, *)      = null
StringUtils.leftPad("", 3, "z")      = "zzz"
StringUtils.leftPad("bat", 3, "yz")  = "bat"
StringUtils.leftPad("bat", 5, "yz")  = "yzbat"
StringUtils.leftPad("bat", 8, "yz")  = "yzyzybat"
StringUtils.leftPad("bat", 1, "yz")  = "bat"
StringUtils.leftPad("bat", -1, "yz") = "bat"
StringUtils.leftPad("bat", 5, null)  = "  bat"
StringUtils.leftPad("bat", 5, "")    = "  bat"

Parameters:: str - the String to pad out, may be null; size - the size to pad to; padStr - the String to pad with, null or empty treated as single space

length
```
 static int length(CharSequence cs)
```
Gets a CharSequence length or {@code 0} if the CharSequence is {@code null}.

Parameters:

cs - a CharSequence or {@code null}

center
```
 static String center(String str, int size)
```
Centers a String in a larger String of size {@code size} using the space character (' ').
If the size is less than the String length, the String is returned.A {@code null} String returns {@code null}.A negative size is treated as zero.
Equivalent to {@code center(str, size, " ")}.
```
StringUtils.center(null, *)   = null
StringUtils.center("", 4)     = "    "
StringUtils.center("ab", -1)  = "ab"
StringUtils.center("ab", 4)   = " ab "
StringUtils.center("abcd", 2) = "abcd"
StringUtils.center("a", 4)    = " a  "
```
Parameters:

str - the String to center, may be null

size - the int size of new String, negative treated as zero

center
```
 static String center(String str, int size, char padChar)
```
Centers a String in a larger String of size {@code size}.Uses a supplied character as the value to pad the String with.
If the size is less than the String length, the String is returned.A {@code null} String returns {@code null}.A negative size is treated as zero.
```
StringUtils.center(null, *, *)     = null
StringUtils.center("", 4, ' ')     = "    "
StringUtils.center("ab", -1, ' ')  = "ab"
StringUtils.center("ab", 4, ' ')   = " ab"
StringUtils.center("abcd", 2, ' ') = "abcd"
StringUtils.center("a", 4, ' ')    = " a  "
StringUtils.center("a", 4, 'y')    = "yayy"
```
Parameters:

str - the String to center, may be null

size - the int size of new String, negative treated as zero

padChar - the character to pad the new String with

center

 static String center(String str, int size, String padStr)

Centers a String in a larger String of size {@code size}.Uses a supplied String as the value to pad the String with.

If the size is less than the String length, the String is returned.A {@code null} String returns {@code null}.A negative size is treated as zero.

StringUtils.center(null, *, *)     = null
StringUtils.center("", 4, " ")     = "    "
StringUtils.center("ab", -1, " ")  = "ab"
StringUtils.center("ab", 4, " ")   = " ab"
StringUtils.center("abcd", 2, " ") = "abcd"
StringUtils.center("a", 4, " ")    = " a  "
StringUtils.center("a", 4, "yz")   = "yayz"
StringUtils.center("abc", 7, null) = "  abc  "
StringUtils.center("abc", 7, "")   = "  abc  "

Parameters:: str - the String to center, may be null; size - the int size of new String, negative treated as zero; padStr - the String to pad the new String with, must not be null or empty

upperCase
```
 static String upperCase(String str)
```
Converts a String to upper case as per toUpperCase.
A {@code null} input String returns {@code null}.
```
StringUtils.upperCase(null)  = null
StringUtils.upperCase("")    = ""
StringUtils.upperCase("aBc") = "ABC"
```
Note: As described in the documentation for toUpperCase,the result of this method is affected by the current locale.For platform-independent case transformations, the method lowerCase should be used with a specific locale (e.g. ENGLISH).
Parameters:

str - the String to upper case, may be null

upperCase
```
 static String upperCase(String str, Locale locale)
```
Converts a String to upper case as per toUpperCase.
A {@code null} input String returns {@code null}.
```
StringUtils.upperCase(null, Locale.ENGLISH)  = null
StringUtils.upperCase("", Locale.ENGLISH)    = ""
StringUtils.upperCase("aBc", Locale.ENGLISH) = "ABC"
```
Parameters:

str - the String to upper case, may be null

locale - the locale that defines the case transformation rules, must not be null

lowerCase
```
 static String lowerCase(String str)
```
Converts a String to lower case as per toLowerCase.
A {@code null} input String returns {@code null}.
```
StringUtils.lowerCase(null)  = null
StringUtils.lowerCase("")    = ""
StringUtils.lowerCase("aBc") = "abc"
```
Note: As described in the documentation for toLowerCase,the result of this method is affected by the current locale.For platform-independent case transformations, the method lowerCase should be used with a specific locale (e.g. ENGLISH).
Parameters:

str - the String to lower case, may be null

lowerCase
```
 static String lowerCase(String str, Locale locale)
```
Converts a String to lower case as per toLowerCase.
A {@code null} input String returns {@code null}.
```
StringUtils.lowerCase(null, Locale.ENGLISH)  = null
StringUtils.lowerCase("", Locale.ENGLISH)    = ""
StringUtils.lowerCase("aBc", Locale.ENGLISH) = "abc"
```
Parameters:

str - the String to lower case, may be null

locale - the locale that defines the case transformation rules, must not be null

capitalize
```
 static String capitalize(String str)
```
Capitalizes a String changing the first letter to title case asper toTitleCase. No other letters are changed.
For a word based algorithm, see capitalize.A {@code null} input String returns {@code null}.
```
StringUtils.capitalize(null)  = null
StringUtils.capitalize("")    = ""
StringUtils.capitalize("cat") = "Cat"
StringUtils.capitalize("cAt") = "CAt"
```
Parameters:

str - the String to capitalize, may be null

uncapitalize
```
 static String uncapitalize(String str)
```
Uncapitalizes a String changing the first letter to title case asper toLowerCase. No other letters are changed.
For a word based algorithm, see uncapitalize.A {@code null} input String returns {@code null}.
```
StringUtils.uncapitalize(null)  = null
StringUtils.uncapitalize("")    = ""
StringUtils.uncapitalize("Cat") = "cat"
StringUtils.uncapitalize("CAT") = "cAT"
```
Parameters:

str - the String to uncapitalize, may be null

swapCase
```
 static String swapCase(String str)
```
Swaps the case of a String changing upper and title case tolower 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 swapCase.A {@code null} input String returns {@code null}.
```
StringUtils.swapCase(null)                 = null
StringUtils.swapCase("")                   = ""
StringUtils.swapCase("The dog has a BONE") = "tHE DOG HAS A bone"
```
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.
Parameters:

str - the String to swap case, may be null

countMatches

 static int countMatches(CharSequence str, CharSequence sub)

Counts how many times the substring appears in the larger string.

A {@code null} or empty ("") String input returns {@code 0}.

StringUtils.countMatches(null, *)       = 0
StringUtils.countMatches("", *)         = 0
StringUtils.countMatches("abba", null)  = 0
StringUtils.countMatches("abba", "")    = 0
StringUtils.countMatches("abba", "a")   = 2
StringUtils.countMatches("abba", "ab")  = 1
StringUtils.countMatches("abba", "xxx") = 0

Parameters:: str - the CharSequence to check, may be null; sub - the substring to count, may be null

isAlpha

 static boolean isAlpha(CharSequence cs)

Checks if the CharSequence contains only Unicode letters.

{@code null} will return {@code false}.An empty CharSequence (length()=0) will return {@code false}.

StringUtils.isAlpha(null)   = false
StringUtils.isAlpha("")     = false
StringUtils.isAlpha("  ")   = false
StringUtils.isAlpha("abc")  = true
StringUtils.isAlpha("ab2c") = false
StringUtils.isAlpha("ab-c") = false

Parameters:: cs - the CharSequence to check, may be null

isAlphaSpace

 static boolean isAlphaSpace(CharSequence cs)

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

{@code null} will return {@code false} An empty CharSequence (length()=0) will return {@code true}.

StringUtils.isAlphaSpace(null)   = false
StringUtils.isAlphaSpace("")     = true
StringUtils.isAlphaSpace("  ")   = true
StringUtils.isAlphaSpace("abc")  = true
StringUtils.isAlphaSpace("ab c") = true
StringUtils.isAlphaSpace("ab2c") = false
StringUtils.isAlphaSpace("ab-c") = false

Parameters:: cs - the CharSequence to check, may be null

isAlphanumeric

 static boolean isAlphanumeric(CharSequence cs)

Checks if the CharSequence contains only Unicode letters or digits.

{@code null} will return {@code false}.An empty CharSequence (length()=0) will return {@code false}.

StringUtils.isAlphanumeric(null)   = false
StringUtils.isAlphanumeric("")     = false
StringUtils.isAlphanumeric("  ")   = false
StringUtils.isAlphanumeric("abc")  = true
StringUtils.isAlphanumeric("ab c") = false
StringUtils.isAlphanumeric("ab2c") = true
StringUtils.isAlphanumeric("ab-c") = false

Parameters:: cs - the CharSequence to check, may be null

isAlphanumericSpace

 static boolean isAlphanumericSpace(CharSequence cs)

Checks if the CharSequence contains only Unicode letters, digitsor space ({@code ' '}).

{@code null} will return {@code false}.An empty CharSequence (length()=0) will return {@code true}.

StringUtils.isAlphanumericSpace(null)   = false
StringUtils.isAlphanumericSpace("")     = true
StringUtils.isAlphanumericSpace("  ")   = true
StringUtils.isAlphanumericSpace("abc")  = true
StringUtils.isAlphanumericSpace("ab c") = true
StringUtils.isAlphanumericSpace("ab2c") = true
StringUtils.isAlphanumericSpace("ab-c") = false

Parameters:: cs - the CharSequence to check, may be null

isAsciiPrintable

 static boolean isAsciiPrintable(CharSequence cs)

Checks if the CharSequence contains only ASCII printable characters.

{@code null} will return {@code false}.An empty CharSequence (length()=0) will return {@code true}.

StringUtils.isAsciiPrintable(null)     = false
StringUtils.isAsciiPrintable("")       = true
StringUtils.isAsciiPrintable(" ")      = true
StringUtils.isAsciiPrintable("Ceki")   = true
StringUtils.isAsciiPrintable("ab2c")   = true
StringUtils.isAsciiPrintable("!ab-c~") = true
StringUtils.isAsciiPrintable("\u0020") = true
StringUtils.isAsciiPrintable("\u0021") = true
StringUtils.isAsciiPrintable("\u007e") = true
StringUtils.isAsciiPrintable("\u007f") = false
StringUtils.isAsciiPrintable("Ceki G\u00fclc\u00fc") = false

Parameters:: cs - the CharSequence to check, may be null

isNumeric

 static boolean isNumeric(CharSequence cs)

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

{@code null} will return {@code false}.An empty CharSequence (length()=0) will return {@code false}.

StringUtils.isNumeric(null)   = false
StringUtils.isNumeric("")     = false
StringUtils.isNumeric("  ")   = false
StringUtils.isNumeric("123")  = true
StringUtils.isNumeric("12 3") = false
StringUtils.isNumeric("ab2c") = false
StringUtils.isNumeric("12-3") = false
StringUtils.isNumeric("12.3") = false

Parameters:: cs - the CharSequence to check, may be null

isNumericSpace

 static boolean isNumericSpace(CharSequence cs)

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

{@code null} will return {@code false}.An empty CharSequence (length()=0) will return {@code true}.

StringUtils.isNumericSpace(null)   = false
StringUtils.isNumericSpace("")     = true
StringUtils.isNumericSpace("  ")   = true
StringUtils.isNumericSpace("123")  = true
StringUtils.isNumericSpace("12 3") = true
StringUtils.isNumericSpace("ab2c") = false
StringUtils.isNumericSpace("12-3") = false
StringUtils.isNumericSpace("12.3") = false

Parameters:: cs - the CharSequence to check, may be null

isWhitespace

 static boolean isWhitespace(CharSequence cs)

Checks if the CharSequence contains only whitespace.

{@code null} will return {@code false}.An empty CharSequence (length()=0) will return {@code true}.

StringUtils.isWhitespace(null)   = false
StringUtils.isWhitespace("")     = true
StringUtils.isWhitespace("  ")   = true
StringUtils.isWhitespace("abc")  = false
StringUtils.isWhitespace("ab2c") = false
StringUtils.isWhitespace("ab-c") = false

Parameters:: cs - the CharSequence to check, may be null

isAllLowerCase

 static boolean isAllLowerCase(CharSequence cs)

Checks if the CharSequence contains only lowercase characters.

{@code null} will return {@code false}.An empty CharSequence (length()=0) will return {@code false}.

StringUtils.isAllLowerCase(null)   = false
StringUtils.isAllLowerCase("")     = false
StringUtils.isAllLowerCase("  ")   = false
StringUtils.isAllLowerCase("abc")  = true
StringUtils.isAllLowerCase("abC") = false

Parameters:: cs - the CharSequence to check, may be null

isAllUpperCase

 static boolean isAllUpperCase(CharSequence cs)

Checks if the CharSequence contains only uppercase characters.

{@code null} will return {@code false}.An empty String (length()=0) will return {@code false}.

StringUtils.isAllUpperCase(null)   = false
StringUtils.isAllUpperCase("")     = false
StringUtils.isAllUpperCase("  ")   = false
StringUtils.isAllUpperCase("ABC")  = true
StringUtils.isAllUpperCase("aBC") = false

Parameters:: cs - the CharSequence to check, may be null

defaultString

 static String defaultString(String str)

Returns either the passed in String,or if the String is {@code null}, an empty String ("").

StringUtils.defaultString(null)  = ""
StringUtils.defaultString("")    = ""
StringUtils.defaultString("bat") = "bat"

Parameters:: str - the String to check, may be null

defaultString
```
 static String defaultString(String str, String defaultStr)
```
Returns either the passed in String, or if the String is {@code null}, the value of {@code defaultStr}.
```
StringUtils.defaultString(null, "NULL")  = "NULL"
StringUtils.defaultString("", "NULL")    = ""
StringUtils.defaultString("bat", "NULL") = "bat"
```
Parameters:

str - the String to check, may be null

defaultStr - the default String to returnif the input is {@code null}, may be null

defaultIfBlank

 static <T extends CharSequence> T defaultIfBlank(T str, T defaultStr)

Returns either the passed in CharSequence, or if the CharSequence iswhitespace, empty ("") or {@code null}, the value of {@code defaultStr}.

StringUtils.defaultIfBlank(null, "NULL")  = "NULL"
StringUtils.defaultIfBlank("", "NULL")    = "NULL"
StringUtils.defaultIfBlank(" ", "NULL")   = "NULL"
StringUtils.defaultIfBlank("bat", "NULL") = "bat"
StringUtils.defaultIfBlank("", null)      = null

Parameters:: str - the CharSequence to check, may be null; defaultStr - the default CharSequence to returnif the input is whitespace, empty ("") or {@code null}, may be null

defaultIfEmpty

 static <T extends CharSequence> T defaultIfEmpty(T str, T defaultStr)

Returns either the passed in CharSequence, or if the CharSequence isempty or {@code null}, the value of {@code defaultStr}.

StringUtils.defaultIfEmpty(null, "NULL")  = "NULL"
StringUtils.defaultIfEmpty("", "NULL")    = "NULL"
StringUtils.defaultIfEmpty(" ", "NULL")   = " "
StringUtils.defaultIfEmpty("bat", "NULL") = "bat"
StringUtils.defaultIfEmpty("", null)      = null

Parameters:: str - the CharSequence to check, may be null; defaultStr - the default CharSequence to returnif the input is empty ("") or {@code null}, may be null

reverse

 static String reverse(String str)

Reverses a String as per reverse.

A {@code null} String returns {@code null}.

StringUtils.reverse(null)  = null
StringUtils.reverse("")    = ""
StringUtils.reverse("bat") = "tab"

Parameters:: str - the String to reverse, may be null

reverseDelimited
```
 static String reverseDelimited(String str, char separatorChar)
```
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 delimiteris {@code '.'}).
```
StringUtils.reverseDelimited(null, *)      = null
StringUtils.reverseDelimited("", *)        = ""
StringUtils.reverseDelimited("a.b.c", 'x') = "a.b.c"
StringUtils.reverseDelimited("a.b.c", ".") = "c.b.a"
```
Parameters:

str - the String to reverse, may be null

separatorChar - the separator character to use

abbreviate
```
 static String abbreviate(String str, int maxWidth)
```
Abbreviates a String using ellipses. This will turn"Now is the time for all good men" into "Now is the time for..."
Specifically:
- If {@code str} is less than {@code maxWidth} characterslong, return it.
- Else abbreviate it to {@code (substring(str, 0, max-3) + "...")}.
- If {@code maxWidth} is less than {@code 4}, throw an{@code IllegalArgumentException}.
- In no case will it return a String of length greater than{@code maxWidth}.
```
StringUtils.abbreviate(null, *)      = null
StringUtils.abbreviate("", 4)        = ""
StringUtils.abbreviate("abcdefg", 6) = "abc..."
StringUtils.abbreviate("abcdefg", 7) = "abcdefg"
StringUtils.abbreviate("abcdefg", 8) = "abcdefg"
StringUtils.abbreviate("abcdefg", 4) = "a..."
StringUtils.abbreviate("abcdefg", 3) = IllegalArgumentException
```
Parameters:

str - the String to check, may be null

maxWidth - maximum length of result String, must be at least 4

abbreviate

 static String abbreviate(String str, int offset, int maxWidth)

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

Works like {@code abbreviate(String, int)}, but allows you to specifya "left edge" offset. Note that this left edge is not necessarily going tobe the leftmost character in the result, or the first character following theellipses, but it will appear somewhere in the result.

In no case will it return a String of length greater than {@code maxWidth}.

StringUtils.abbreviate(null, *, *)                = null
StringUtils.abbreviate("", 0, 4)                  = ""
StringUtils.abbreviate("abcdefghijklmno", -1, 10) = "abcdefg..."
StringUtils.abbreviate("abcdefghijklmno", 0, 10)  = "abcdefg..."
StringUtils.abbreviate("abcdefghijklmno", 1, 10)  = "abcdefg..."
StringUtils.abbreviate("abcdefghijklmno", 4, 10)  = "abcdefg..."
StringUtils.abbreviate("abcdefghijklmno", 5, 10)  = "...fghi..."
StringUtils.abbreviate("abcdefghijklmno", 6, 10)  = "...ghij..."
StringUtils.abbreviate("abcdefghijklmno", 8, 10)  = "...ijklmno"
StringUtils.abbreviate("abcdefghijklmno", 10, 10) = "...ijklmno"
StringUtils.abbreviate("abcdefghijklmno", 12, 10) = "...ijklmno"
StringUtils.abbreviate("abcdefghij", 0, 3)        = IllegalArgumentException
StringUtils.abbreviate("abcdefghij", 5, 6)        = IllegalArgumentException

Parameters:: str - the String to check, may be null; offset - left edge of source String; maxWidth - maximum length of result String, must be at least 4

abbreviateMiddle
```
 static String abbreviateMiddle(String str, String middle, int length)
```
Abbreviates a String to the length passed, replacing the middle characters with the suppliedreplacement String.
This abbreviation only occurs if the following criteria is met:
- Neither the String for abbreviation nor the replacement String are null or empty
- The length to truncate to is less than the length of the supplied String
- The length to truncate to is greater than 0
- The abbreviated String will have enough room for the length supplied replacement Stringand the first and last characters of the supplied String for abbreviation
Otherwise, the returned String will be the same as the supplied String for abbreviation.
```
StringUtils.abbreviateMiddle(null, null, 0)      = null
StringUtils.abbreviateMiddle("abc", null, 0)      = "abc"
StringUtils.abbreviateMiddle("abc", ".", 0)      = "abc"
StringUtils.abbreviateMiddle("abc", ".", 3)      = "abc"
StringUtils.abbreviateMiddle("abcdef", ".", 4)     = "ab.f"
```
Parameters:

str - the String to abbreviate, may be null

middle - the String to replace the middle characters with, may be null

length - the length to abbreviate {@code str} to.

difference

 static String difference(String str1, String str2)

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.)

For example, {@code difference("i am a machine", "i am a robot") -> "robot"}.

StringUtils.difference(null, null) = null
StringUtils.difference("", "") = ""
StringUtils.difference("", "abc") = "abc"
StringUtils.difference("abc", "") = ""
StringUtils.difference("abc", "abc") = ""
StringUtils.difference("ab", "abxyz") = "xyz"
StringUtils.difference("abcde", "abxyz") = "xyz"
StringUtils.difference("abcde", "xyz") = "xyz"

Parameters:: str1 - the first String, may be null; str2 - the second String, may be null

indexOfDifference

 static int indexOfDifference(CharSequence cs1, CharSequence cs2)

Compares two CharSequences, and returns the index at which theCharSequences begin to differ.

For example, {@code indexOfDifference("i am a machine", "i am a robot") -> 7}

StringUtils.indexOfDifference(null, null) = -1
StringUtils.indexOfDifference("", "") = -1
StringUtils.indexOfDifference("", "abc") = 0
StringUtils.indexOfDifference("abc", "") = 0
StringUtils.indexOfDifference("abc", "abc") = -1
StringUtils.indexOfDifference("ab", "abxyz") = 2
StringUtils.indexOfDifference("abcde", "abxyz") = 2
StringUtils.indexOfDifference("abcde", "xyz") = 0

Parameters:: cs1 - the first CharSequence, may be null; cs2 - the second CharSequence, may be null

indexOfDifference

 static int indexOfDifference(Array<CharSequence> css)

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

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

StringUtils.indexOfDifference(null) = -1
StringUtils.indexOfDifference(new String[] {}) = -1
StringUtils.indexOfDifference(new String[] {"abc"}) = -1
StringUtils.indexOfDifference(new String[] {null, null}) = -1
StringUtils.indexOfDifference(new String[] {"", ""}) = -1
StringUtils.indexOfDifference(new String[] {"", null}) = 0
StringUtils.indexOfDifference(new String[] {"abc", null, null}) = 0
StringUtils.indexOfDifference(new String[] {null, null, "abc"}) = 0
StringUtils.indexOfDifference(new String[] {"", "abc"}) = 0
StringUtils.indexOfDifference(new String[] {"abc", ""}) = 0
StringUtils.indexOfDifference(new String[] {"abc", "abc"}) = -1
StringUtils.indexOfDifference(new String[] {"abc", "a"}) = 1
StringUtils.indexOfDifference(new String[] {"ab", "abxyz"}) = 2
StringUtils.indexOfDifference(new String[] {"abcde", "abxyz"}) = 2
StringUtils.indexOfDifference(new String[] {"abcde", "xyz"}) = 0
StringUtils.indexOfDifference(new String[] {"xyz", "abcde"}) = 0
StringUtils.indexOfDifference(new String[] {"i am a machine", "i am a robot"}) = 7

Parameters:: css - array of CharSequences, entries may be null

getCommonPrefix

 static String getCommonPrefix(Array<String> strs)

Compares all Strings in an array and returns the initial sequence ofcharacters that is common to all of them.

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

StringUtils.getCommonPrefix(null) = ""
StringUtils.getCommonPrefix(new String[] {}) = ""
StringUtils.getCommonPrefix(new String[] {"abc"}) = "abc"
StringUtils.getCommonPrefix(new String[] {null, null}) = ""
StringUtils.getCommonPrefix(new String[] {"", ""}) = ""
StringUtils.getCommonPrefix(new String[] {"", null}) = ""
StringUtils.getCommonPrefix(new String[] {"abc", null, null}) = ""
StringUtils.getCommonPrefix(new String[] {null, null, "abc"}) = ""
StringUtils.getCommonPrefix(new String[] {"", "abc"}) = ""
StringUtils.getCommonPrefix(new String[] {"abc", ""}) = ""
StringUtils.getCommonPrefix(new String[] {"abc", "abc"}) = "abc"
StringUtils.getCommonPrefix(new String[] {"abc", "a"}) = "a"
StringUtils.getCommonPrefix(new String[] {"ab", "abxyz"}) = "ab"
StringUtils.getCommonPrefix(new String[] {"abcde", "abxyz"}) = "ab"
StringUtils.getCommonPrefix(new String[] {"abcde", "xyz"}) = ""
StringUtils.getCommonPrefix(new String[] {"xyz", "abcde"}) = ""
StringUtils.getCommonPrefix(new String[] {"i am a machine", "i am a robot"}) = "i am a "

Parameters:: strs - array of String objects, entries may be null

getLevenshteinDistance

 static int getLevenshteinDistance(CharSequence s, CharSequence t)

Find the Levenshtein distance between two Strings.

This is the number of changes needed to change one String intoanother, where each change is a single character modification (deletion,insertion or substitution).

The previous implementation of the Levenshtein distance algorithmwas from http://www.merriampark.com/ld.htm

Chas Emerick has written an implementation in Java, which avoids an OutOfMemoryErrorwhich can occur when my Java implementation is used with very large strings.This implementation of the Levenshtein distance algorithmis from http://www.merriampark.com/ldjava.htm

StringUtils.getLevenshteinDistance(null, *)             = IllegalArgumentException
StringUtils.getLevenshteinDistance(*, null)             = IllegalArgumentException
StringUtils.getLevenshteinDistance("","")               = 0
StringUtils.getLevenshteinDistance("","a")              = 1
StringUtils.getLevenshteinDistance("aaapppp", "")       = 7
StringUtils.getLevenshteinDistance("frog", "fog")       = 1
StringUtils.getLevenshteinDistance("fly", "ant")        = 3
StringUtils.getLevenshteinDistance("elephant", "hippo") = 7
StringUtils.getLevenshteinDistance("hippo", "elephant") = 7
StringUtils.getLevenshteinDistance("hippo", "zzzzzzzz") = 8
StringUtils.getLevenshteinDistance("hello", "hallo")    = 1

Parameters:: s - the first String, must not be null; t - the second String, must not be null

getLevenshteinDistance

 static int getLevenshteinDistance(CharSequence s, CharSequence t, int threshold)

Find the Levenshtein distance between two Strings if it's less than or equal to a given threshold.

This is the number of changes needed to change one String intoanother, where each change is a single character modification (deletion,insertion or substitution).

This implementation follows from Algorithms on Strings, Trees and Sequences by Dan Gusfieldand Chas Emerick's implementation of the Levenshtein distance algorithm fromhttp://www.merriampark.com/ld.htm

StringUtils.getLevenshteinDistance(null, *, *)             = IllegalArgumentException
StringUtils.getLevenshteinDistance(*, null, *)             = IllegalArgumentException
StringUtils.getLevenshteinDistance(*, *, -1)               = IllegalArgumentException
StringUtils.getLevenshteinDistance("","", 0)               = 0
StringUtils.getLevenshteinDistance("aaapppp", "", 8)       = 7
StringUtils.getLevenshteinDistance("aaapppp", "", 7)       = 7
StringUtils.getLevenshteinDistance("aaapppp", "", 6))      = -1
StringUtils.getLevenshteinDistance("elephant", "hippo", 7) = 7
StringUtils.getLevenshteinDistance("elephant", "hippo", 6) = -1
StringUtils.getLevenshteinDistance("hippo", "elephant", 7) = 7
StringUtils.getLevenshteinDistance("hippo", "elephant", 6) = -1

Parameters:: s - the first String, must not be null; t - the second String, must not be null; threshold - the target threshold, must not be negative

startsWith

 static boolean startsWith(CharSequence str, CharSequence prefix)

Check if a CharSequence starts with a specified prefix.

{@code null}s are handled without exceptions. Two {@code null} references are considered to be equal. The comparison is case sensitive.

StringUtils.startsWith(null, null)      = true
StringUtils.startsWith(null, "abc")     = false
StringUtils.startsWith("abcdef", null)  = false
StringUtils.startsWith("abcdef", "abc") = true
StringUtils.startsWith("ABCDEF", "abc") = false

Parameters:: str - the CharSequence to check, may be null; prefix - the prefix to find, may be null

startsWithIgnoreCase

 static boolean startsWithIgnoreCase(CharSequence str, CharSequence prefix)

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

{@code null}s are handled without exceptions. Two {@code null} references are considered to be equal. The comparison is case insensitive.

StringUtils.startsWithIgnoreCase(null, null)      = true
StringUtils.startsWithIgnoreCase(null, "abc")     = false
StringUtils.startsWithIgnoreCase("abcdef", null)  = false
StringUtils.startsWithIgnoreCase("abcdef", "abc") = true
StringUtils.startsWithIgnoreCase("ABCDEF", "abc") = true

Parameters:: str - the CharSequence to check, may be null; prefix - the prefix to find, may be null

startsWithAny

 static boolean startsWithAny(CharSequence string, Array<CharSequence> searchStrings)

Check if a CharSequence starts with any of an array of specified strings.

StringUtils.startsWithAny(null, null)      = false
StringUtils.startsWithAny(null, new String[] {"abc"})  = false
StringUtils.startsWithAny("abcxyz", null)     = false
StringUtils.startsWithAny("abcxyz", new String[] {""}) = false
StringUtils.startsWithAny("abcxyz", new String[] {"abc"}) = true
StringUtils.startsWithAny("abcxyz", new String[] {null, "xyz", "abc"}) = true

Parameters:: string - the CharSequence to check, may be null; searchStrings - the CharSequences to find, may be null or empty

endsWith

 static boolean endsWith(CharSequence str, CharSequence suffix)

Check if a CharSequence ends with a specified suffix.

{@code null}s are handled without exceptions. Two {@code null} references are considered to be equal. The comparison is case sensitive.

StringUtils.endsWith(null, null)      = true
StringUtils.endsWith(null, "def")     = false
StringUtils.endsWith("abcdef", null)  = false
StringUtils.endsWith("abcdef", "def") = true
StringUtils.endsWith("ABCDEF", "def") = false
StringUtils.endsWith("ABCDEF", "cde") = false

Parameters:: str - the CharSequence to check, may be null; suffix - the suffix to find, may be null

endsWithIgnoreCase

 static boolean endsWithIgnoreCase(CharSequence str, CharSequence suffix)

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

{@code null}s are handled without exceptions. Two {@code null} references are considered to be equal. The comparison is case insensitive.

StringUtils.endsWithIgnoreCase(null, null)      = true
StringUtils.endsWithIgnoreCase(null, "def")     = false
StringUtils.endsWithIgnoreCase("abcdef", null)  = false
StringUtils.endsWithIgnoreCase("abcdef", "def") = true
StringUtils.endsWithIgnoreCase("ABCDEF", "def") = true
StringUtils.endsWithIgnoreCase("ABCDEF", "cde") = false

Parameters:: str - the CharSequence to check, may be null; suffix - the suffix to find, may be null

normalizeSpace
```
 static String normalizeSpace(String str)
```
Similar to http://www.w3.org/TR/xpath/#function-normalize-space
The function returns the argument string with whitespace normalized by usingtrim to remove leading and trailing whitespaceand then replacing sequences of whitespace characters by a single space.
In XML Whitespace characters are the same as those allowed by the S production, which is S ::= (#x20 | #x9 | #xD | #xA)+

Parameters:

str - the source String to normalize whitespaces from, may be null

endsWithAny

 static boolean endsWithAny(CharSequence string, Array<CharSequence> searchStrings)

Check if a CharSequence ends with any of an array of specified strings.

StringUtils.endsWithAny(null, null)      = false
StringUtils.endsWithAny(null, new String[] {"abc"})  = false
StringUtils.endsWithAny("abcxyz", null)     = false
StringUtils.endsWithAny("abcxyz", new String[] {""}) = true
StringUtils.endsWithAny("abcxyz", new String[] {"xyz"}) = true
StringUtils.endsWithAny("abcxyz", new String[] {null, "xyz", "abc"}) = true

Parameters:: string - the CharSequence to check, may be null; searchStrings - the CharSequences to find, may be null or empty

toString
```
 static String toString(Array<byte> bytes, String charsetName)
```
Converts a byte[] to a String using the specified character encoding.

Parameters:

bytes - the byte array to read from

charsetName - the encoding to use, if null then use the platform default

Class StringUtils

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

StringUtils

Method Detail

isEmpty

isNotEmpty

isBlank

isNotBlank

trim

trimToNull

trimToEmpty

strip

stripToNull

stripToEmpty

strip

stripStart

stripEnd

stripAll

stripAll

stripAccents

equals

equalsIgnoreCase

indexOf

indexOf

indexOf

indexOf

ordinalIndexOf

indexOfIgnoreCase

indexOfIgnoreCase

lastIndexOf

lastIndexOf

lastIndexOf

lastOrdinalIndexOf

lastIndexOf

lastIndexOfIgnoreCase

lastIndexOfIgnoreCase

contains

contains

containsIgnoreCase

containsWhitespace

indexOfAny

indexOfAny

containsAny

containsAny

indexOfAnyBut

indexOfAnyBut

containsOnly

containsOnly

containsNone

containsNone

indexOfAny

lastIndexOfAny

substring

substring

left

right

mid

substringBefore

substringAfter

substringBeforeLast

substringAfterLast

substringBetween

substringBetween

substringsBetween

split

split

split

split

splitByWholeSeparator

splitByWholeSeparator

splitByWholeSeparatorPreserveAllTokens

splitByWholeSeparatorPreserveAllTokens

splitPreserveAllTokens

splitPreserveAllTokens

splitPreserveAllTokens

splitPreserveAllTokens