Operations on
String
that are
null
safe.
The StringUtils class defines certain words related to String handling.
null"")' ', char 32)Character.isWhitespace(char)String.trim()StringUtils handles null input Strings quietly. That is to say that a null input will return null. Where a boolean or int is being returned details vary by method.
A side effect of the null handling is that a NullPointerException should be considered a bug in StringUtils.
Methods in this class include sample code in their Javadoc comments to explain their operation. The symbol * is used to indicate any input including null.
#ThreadSafe#
Fields
A String for carriage return CR ("\r").
static final int
Represents a failed index search.
A String for linefeed LF ("\n").
A String for a space character.
Constructors
Abbreviates a String using ellipses.
Abbreviates a String using ellipses.
Abbreviates a String using another given String as replacement marker.
Abbreviates a String using a given replacement marker.
Abbreviates a String to the length passed, replacing the middle characters with the supplied replacement String.
Centers a String in a larger String of size size using the space character (' ').
Centers a String in a larger String of size size.
Centers a String in a larger String of size size.
Removes one newline from end of a String if it's there, otherwise leave it alone.
Remove the last character from a String.
static int
static int
Compare two Strings lexicographically, as per
String.compareTo(String)
, returning :
int = 0
, if
str1
is equal to
str2
(or both
null
)
int < 0
, if
str1
is less than
str2 int > 0
, if
str1
is greater than
str2
static int
static int
Compare two Strings lexicographically, ignoring case differences, as per
String.compareToIgnoreCase(String)
, returning :
int = 0
, if
str1
is equal to
str2
(or both
null
)
int < 0
, if
str1
is less than
str2 int > 0
, if
str1
is greater than
str2
static boolean
Tests if CharSequence contains a search character, handling null.
static boolean
static boolean
Tests if the CharSequence contains any character in the given set of characters.
static boolean
Tests if the CharSequence contains any character in the given set of characters.
static boolean
static boolean
static boolean
static boolean
Tests that the CharSequence does not contain certain characters.
static boolean
Tests that the CharSequence does not contain certain characters.
static boolean
Tests if the CharSequence contains only certain characters.
static boolean
Tests if the CharSequence contains only certain characters.
static boolean
Tests whether the given CharSequence contains any whitespace characters.
static int
Counts how many times the char appears in the given string.
static int
Counts how many times the substring appears in the larger string.
Returns either the passed in CharSequence, or if the CharSequence is
blank
(whitespaces, empty (
""
) or
null
), the value of
defaultStr
.
Returns either the passed in CharSequence, or if the CharSequence is empty or null, the value of defaultStr.
Returns either the passed in String, or if the String is null, an empty String ("").
Compares two Strings, and returns the portion where they differ.
static boolean
static boolean
static boolean
static boolean
static boolean
static boolean
static boolean
Returns the first value in the array which is not empty (""), null or whitespace only.
Returns the first value in the array which is not empty.
static byte[]
static byte[]
Compares all Strings in an array and returns the initial sequence of characters that is common to all of them.
Checks if a String str contains Unicode digits, if yes then concatenate all the digits in str and return it as a String.
static int
Returns either the passed in CharSequence, or if the CharSequence is
blank
(whitespaces, empty (
""
) or
null
), the value supplied by
defaultStrSupplier
.
Returns either the passed in CharSequence, or if the CharSequence is empty or null, the value supplied by defaultStrSupplier.
static double
static int
static int
static int
Returns the index within seq of the first occurrence of the specified character.
static int
Returns the index within seq of the first occurrence of the specified character, starting the search at the specified index.
static int
static int
static int
Search a CharSequence to find the first index of any character in the given set of characters.
static int
Find the first index of any of a set of potential substrings.
static int
Search a CharSequence to find the first index of any character in the given set of characters.
static int
Searches a CharSequence to find the first index of any character not in the given set of characters, i.e., find index i of first char in cs such that (cs.codePointAt(i) ∉ { x ∈ codepoints(searchChars) })
static int
Search a CharSequence to find the first index of any character not in the given set of characters, i.e., find index i of first char in seq such that (seq.codePointAt(i) ∉ { x ∈ codepoints(searchChars) })
static int
Compares all CharSequences in an array and returns the index at which the CharSequences begin to differ.
static int
Compares two CharSequences, and returns the index at which the CharSequences begin to differ.
static int
static int
static boolean
Tests if all of the CharSequences are empty (""), null or whitespace only.
static boolean
Tests if all of the CharSequences are empty ("") or null.
static boolean
Tests if the CharSequence contains only lowercase characters.
static boolean
Tests if the CharSequence contains only uppercase characters.
static boolean
Tests if the CharSequence contains only Unicode letters.
static boolean
Tests if the CharSequence contains only Unicode letters or digits.
static boolean
Tests if the CharSequence contains only Unicode letters, digits or space (' ').
static boolean
Tests if the CharSequence contains only Unicode letters and space (' ').
static boolean
Tests if any of the CharSequences are
blank
(whitespaces, empty (
""
) or
null
).
static boolean
Tests if any of the CharSequences are empty ("") or null.
static boolean
Tests if the CharSequence contains only ASCII printable characters.
static boolean
static boolean
Tests if a CharSequence is empty ("") or null.
static boolean
Tests if the CharSequence contains mixed casing of both uppercase and lowercase characters.
static boolean
Tests if none of the CharSequences are empty (""), null or whitespace only.
static boolean
Tests if none of the CharSequences are empty ("") or null.
static boolean
Tests if a CharSequence is not
blank
(whitespaces, empty (
""
) or
null
).
static boolean
Tests if a CharSequence is not empty ("") and not null.
static boolean
Tests if the CharSequence contains only Unicode digits.
static boolean
Tests if the CharSequence contains only Unicode digits or space (' ').
static boolean
Tests if the CharSequence contains only whitespace.
join(boolean[] array, char delimiter)
Joins the elements of the provided array into a single String containing the provided list of elements.
join(boolean[] array, char delimiter, int startIndex, int endIndex)
Joins the elements of the provided array into a single String containing the provided list of elements.
join(byte[] array, char delimiter)
Joins the elements of the provided array into a single String containing the provided list of elements.
join(byte[] array, char delimiter, int startIndex, int endIndex)
Joins the elements of the provided array into a single String containing the provided list of elements.
join(char[] array, char delimiter)
Joins the elements of the provided array into a single String containing the provided list of elements.
join(char[] array, char delimiter, int startIndex, int endIndex)
Joins the elements of the provided array into a single String containing the provided list of elements.
join(double[] array, char delimiter)
Joins the elements of the provided array into a single String containing the provided list of elements.
join(double[] array, char delimiter, int startIndex, int endIndex)
Joins the elements of the provided array into a single String containing the provided list of elements.
join(float[] array, char delimiter)
Joins the elements of the provided array into a single String containing the provided list of elements.
join(float[] array, char delimiter, int startIndex, int endIndex)
Joins the elements of the provided array into a single String containing the provided list of elements.
join(int[] array, char separator)
Joins the elements of the provided array into a single String containing the provided list of elements.
join(int[] array, char delimiter, int startIndex, int endIndex)
Joins the elements of the provided array into a single String containing the provided list of elements.
join(long[] array, char separator)
Joins the elements of the provided array into a single String containing the provided list of elements.
join(long[] array, char delimiter, int startIndex, int endIndex)
Joins the elements of the provided array into a single String containing the provided list of elements.
join(short[] array, char delimiter)
Joins the elements of the provided array into a single String containing the provided list of elements.
join(short[] array, char delimiter, int startIndex, int endIndex)
Joins the elements of the provided array into a single String containing the provided list of elements.
Joins the elements of the provided
Iterable
into a single String containing the provided elements.
Joins the elements of the provided
Iterable
into a single String containing the provided elements.
Joins the elements of the provided array into a single String containing the provided list of elements.
join(Object[] array, char delimiter, int startIndex, int endIndex)
Joins the elements of the provided array into a single String containing the provided list of elements.
Joins the elements of the provided array into a single String containing the provided list of elements.
Joins the elements of the provided array into a single String containing the provided list of elements.
Joins the elements of the provided
Iterator
into a single String containing the provided elements.
Joins the elements of the provided
Iterator
into a single String containing the provided elements.
join(List<?> list, char separator, int startIndex, int endIndex)
Joins the elements of the provided
List
into a single String containing the provided list of elements.
Joins the elements of the provided
List
into a single String containing the provided list of elements.
Joins the elements of the provided array into a single String containing the provided list of elements.
Joins the elements of the provided varargs into a single String containing the provided elements.
static int
Returns the index within seq of the last occurrence of the specified character.
static int
Returns the index within seq of the last occurrence of the specified character, searching backward starting at the specified index.
static int
static int
static int
Find the latest index of any substring in a set of potential substrings.
static int
static int
static int
Finds the n-th last index within a String, handling null.
Gets the leftmost len characters of a String.
Left pad a String with spaces (' ').
Left pad a String with a specified character.
Left pad a String with a specified String.
static int
Gets a CharSequence length or 0 if the CharSequence is null.
Gets len characters from the middle of a String.
static int
Finds the n-th index within a CharSequence, handling null.
Overlays part of a String with another String.
Removes all occurrences of a character from within the source string.
Removes a char only if it is at the beginning of a source string, otherwise returns the source string.
repeat(char repeat, int count)
Returns padding using the specified delimiter repeated to a given length.
Repeats a String repeat times to form a new String.
Repeats a String repeat times to form a new String, with a String separator injected each time.
Replaces all occurrences of a character in a String with another.
Replaces multiple characters in a String in one go.
Replaces all occurrences of Strings within another String.
Replaces all occurrences of Strings within another String.
Reverses a String that is delimited by a specific character.
Gets the rightmost len characters of a String.
Right pad a String with spaces (' ').
Right pad a String with a specified character.
Right pad a String with a specified String.
Rotate (circular shift) a String of shift characters.
Splits the provided text into an array, using whitespace as the separator.
Splits the provided text into an array, separator specified.
Splits the provided text into an array, separators specified.
Splits the provided text into an array with a maximum length, separators specified.
Splits a String by Character type as returned by java.lang.Character.getType(char).
Splits a String by Character type as returned by java.lang.Character.getType(char).
Splits the provided text into an array, separator string specified.
Splits the provided text into an array, separator string specified.
Splits the provided text into an array, separator string specified.
Splits the provided text into an array, separator string specified.
Splits the provided text into an array, using whitespace as the separator, preserving all tokens, including empty tokens created by adjacent separators.
Splits the provided text into an array, separator specified, preserving all tokens, including empty tokens created by adjacent separators.
Splits the provided text into an array, separators specified, preserving all tokens, including empty tokens created by adjacent separators.
Splits the provided text into an array with a maximum length, separators specified, preserving all tokens, including empty tokens created by adjacent separators.
static boolean
static boolean
static boolean
Strips whitespace from the start and end of a String.
Strips any of a set of characters from the start and end of a String.
Removes diacritics (~= accents) from a string.
Strips whitespace from the start and end of every String in an array.
Strips any of a set of characters from the start and end of every String in an array.
Strips any of a set of characters from the end of a String.
Strips any of a set of characters from the start of a String.
Strips whitespace from the start and end of a String returning an empty String if null input.
Strips whitespace from the start and end of a String returning null if the String is empty ("") after the strip.
Gets a substring from the specified String avoiding exceptions.
Gets a substring from the specified String avoiding exceptions.
Gets the substring after the first occurrence of a separator.
Gets the substring after the first occurrence of a separator.
Gets the substring after the last occurrence of a separator.
Gets the substring after the last occurrence of a separator.
Gets the substring before the first occurrence of a separator.
Gets the substring before the first occurrence of a separator.
Gets the substring before the last occurrence of a separator.
Gets the String that is nested in between two instances of the same String.
Gets the String that is nested in between two Strings.
Searches a String for substrings delimited by a start and end tag, returning all matching substrings in an array.
Swaps the case of a String changing upper and title case to lower case, and lower case to upper case.
static int[]
Converts a byte[] to a String using the specified character encoding.
Converts the given source String as a lower-case using the
Locale.ROOT
locale in a null-safe manner.
Converts the given source String as an upper-case using the
Locale.ROOT
locale in a null-safe manner.
Removes control characters (char <= 32) from both ends of this String, handling null by returning null.
Removes control characters (char <= 32) from both ends of this String returning an empty String ("") if the String is empty ("") after the trim or if it is null.
Removes control characters (char <= 32) from both ends of this String returning null if the String is empty ("") after the trim or if it is null.
Unwraps a given string from a character.
Unwraps a given string from another string.
Returns the string representation of the char array or null.
Wraps a string with a char.
Wraps a String with another String.
Wraps a string with a char if that char is missing from the start or end of the given string.
Wraps a string with a string if that string is missing from the start or end of the given string.
Methods inherited from class java.lang.Objectclone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, waitA String for a space character.
The empty String "".
A String for linefeed LF ("\n").
A String for carriage return CR ("\r").
Represents a failed index search.
StringUtils
instances should NOT be constructed in standard programming. Instead, the class should be used as
StringUtils.trim(" foo ");
.
This constructor is public to permit tools that require a JavaBean instance to operate.
Abbreviates a String using ellipses. This will turn "Now is the time for all good men" into "Now is the time for..."
Specifically:
str is less than or equal to maxWidth, return str.(substring(str, 0, max-3) + "...").maxWidth is less than 4, throw an IllegalArgumentException.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
str - the String to check, may be null
maxWidth - maximum length of result String, must be at least 4
null if null String input
IllegalArgumentException - if the width is too small
Abbreviates a String using ellipses. This will turn "Now is the time for all good men" into "...is the time for..."
Works like abbreviate(String, int), but allows you to specify a "left edge" offset. Note that this left edge is not necessarily going to be the leftmost character in the result, or the first character following the ellipses, but it will appear somewhere in the result.
In no case will it return a String of length greater than 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
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
null if null String input
IllegalArgumentException - if the width is too small
Abbreviates a String using another given String as replacement marker. This will turn "Now is the time for all good men" into "Now is the time for..." if "..." was defined as the replacement marker.
Specifically:
str is less than or equal to maxWidth, return str.(substring(str, 0, max-abbrevMarker.length) + abbrevMarker).maxWidth is less than abbrevMarker.length + 1, throw an IllegalArgumentException.maxWidth. StringUtils.abbreviate(null, "...", *) = null
StringUtils.abbreviate("abcdefg", null, *) = "abcdefg"
StringUtils.abbreviate("", "...", 4) = ""
StringUtils.abbreviate("abcdefg", ".", 5) = "abcd."
StringUtils.abbreviate("abcdefg", ".", 7) = "abcdefg"
StringUtils.abbreviate("abcdefg", ".", 8) = "abcdefg"
StringUtils.abbreviate("abcdefg", "..", 4) = "ab.."
StringUtils.abbreviate("abcdefg", "..", 3) = "a.."
StringUtils.abbreviate("abcdefg", "..", 2) = IllegalArgumentException
StringUtils.abbreviate("abcdefg", "...", 3) = IllegalArgumentException
str - the String to check, may be null
abbrevMarker - the String used as replacement marker
maxWidth - maximum length of result String, must be at least abbrevMarker.length + 1
null if null String input
IllegalArgumentException - if the width is too small
Abbreviates a String using a given replacement marker. This will turn "Now is the time for all good men" into "...is the time for..." if "..." was defined as the replacement marker.
Works like abbreviate(String, String, int), but allows you to specify a "left edge" offset. Note that this left edge is not necessarily going to be the leftmost character in the result, or the first character following the replacement marker, but it will appear somewhere in the result.
In no case will it return a String of length greater than maxWidth.
StringUtils.abbreviate(null, null, *, *) = null
StringUtils.abbreviate("abcdefghijklmno", null, *, *) = "abcdefghijklmno"
StringUtils.abbreviate("", "...", 0, 4) = ""
StringUtils.abbreviate("abcdefghijklmno", "---", -1, 10) = "abcdefg---"
StringUtils.abbreviate("abcdefghijklmno", ",", 0, 10) = "abcdefghi,"
StringUtils.abbreviate("abcdefghijklmno", ",", 1, 10) = "abcdefghi,"
StringUtils.abbreviate("abcdefghijklmno", ",", 2, 10) = "abcdefghi,"
StringUtils.abbreviate("abcdefghijklmno", "::", 4, 10) = "::efghij::"
StringUtils.abbreviate("abcdefghijklmno", "...", 6, 10) = "...ghij..."
StringUtils.abbreviate("abcdefghijklmno", "*", 9, 10) = "*ghijklmno"
StringUtils.abbreviate("abcdefghijklmno", "'", 10, 10) = "'ghijklmno"
StringUtils.abbreviate("abcdefghijklmno", "!", 12, 10) = "!ghijklmno"
StringUtils.abbreviate("abcdefghij", "abra", 0, 4) = IllegalArgumentException
StringUtils.abbreviate("abcdefghij", "...", 5, 6) = IllegalArgumentException
str - the String to check, may be null
abbrevMarker - the String used as replacement marker
offset - left edge of source String
maxWidth - maximum length of result String, must be at least 4
null if null String input
IllegalArgumentException - if the width is too small
Abbreviates a String to the length passed, replacing the middle characters with the supplied replacement String.
This abbreviation only occurs if the following criteria is met:
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"
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 str to.
Appends the suffix to the end of the string if the string does not already end with any of the suffixes.
StringUtils.appendIfMissing(null, null) = null
StringUtils.appendIfMissing("abc", null) = "abc"
StringUtils.appendIfMissing("", "xyz" = "xyz"
StringUtils.appendIfMissing("abc", "xyz") = "abcxyz"
StringUtils.appendIfMissing("abcxyz", "xyz") = "abcxyz"
StringUtils.appendIfMissing("abcXYZ", "xyz") = "abcXYZxyz"
With additional suffixes,
StringUtils.appendIfMissing(null, null, null) = null
StringUtils.appendIfMissing("abc", null, null) = "abc"
StringUtils.appendIfMissing("", "xyz", null) = "xyz"
StringUtils.appendIfMissing("abc", "xyz", new CharSequence[]{null}) = "abcxyz"
StringUtils.appendIfMissing("abc", "xyz", "") = "abc"
StringUtils.appendIfMissing("abc", "xyz", "mno") = "abcxyz"
StringUtils.appendIfMissing("abcxyz", "xyz", "mno") = "abcxyz"
StringUtils.appendIfMissing("abcmno", "xyz", "mno") = "abcmno"
StringUtils.appendIfMissing("abcXYZ", "xyz", "mno") = "abcXYZxyz"
StringUtils.appendIfMissing("abcMNO", "xyz", "mno") = "abcMNOxyz"
str - The string.
suffix - The suffix to append to the end of the string.
suffixes - Additional suffixes that are valid terminators.
Appends the suffix to the end of the string if the string does not already end, case-insensitive, with any of the suffixes.
StringUtils.appendIfMissingIgnoreCase(null, null) = null
StringUtils.appendIfMissingIgnoreCase("abc", null) = "abc"
StringUtils.appendIfMissingIgnoreCase("", "xyz") = "xyz"
StringUtils.appendIfMissingIgnoreCase("abc", "xyz") = "abcxyz"
StringUtils.appendIfMissingIgnoreCase("abcxyz", "xyz") = "abcxyz"
StringUtils.appendIfMissingIgnoreCase("abcXYZ", "xyz") = "abcXYZ"
With additional suffixes,
StringUtils.appendIfMissingIgnoreCase(null, null, null) = null
StringUtils.appendIfMissingIgnoreCase("abc", null, null) = "abc"
StringUtils.appendIfMissingIgnoreCase("", "xyz", null) = "xyz"
StringUtils.appendIfMissingIgnoreCase("abc", "xyz", new CharSequence[]{null}) = "abcxyz"
StringUtils.appendIfMissingIgnoreCase("abc", "xyz", "") = "abc"
StringUtils.appendIfMissingIgnoreCase("abc", "xyz", "mno") = "abcxyz"
StringUtils.appendIfMissingIgnoreCase("abcxyz", "xyz", "mno") = "abcxyz"
StringUtils.appendIfMissingIgnoreCase("abcmno", "xyz", "mno") = "abcmno"
StringUtils.appendIfMissingIgnoreCase("abcXYZ", "xyz", "mno") = "abcXYZ"
StringUtils.appendIfMissingIgnoreCase("abcMNO", "xyz", "mno") = "abcMNO"
str - The string.
suffix - The suffix to append to the end of the string.
suffixes - Additional suffixes that are valid terminators.
Capitalizes a String changing the first character to title case as per
Character.toTitleCase(int)
. No other characters are changed.
For a word based algorithm, see WordUtils.capitalize(String). A null input String returns null.
StringUtils.capitalize(null) = null
StringUtils.capitalize("") = ""
StringUtils.capitalize("cat") = "Cat"
StringUtils.capitalize("cAt") = "CAt"
StringUtils.capitalize("'cat'") = "'cat'"
str - the String to capitalize, may be null
null if null String input
Centers a String in a larger String of size
size
using the space character (' ').
If the size is less than the String length, the original String is returned. A null String returns null. A negative size is treated as zero.
Equivalent to 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 "
str - the String to center, may be null
size - the int size of new String, negative treated as zero
null if null String input
Centers a String in a larger String of size
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 null String returns 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"
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
null if null String input
Centers a String in a larger String of size
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 null String returns 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 "
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
null if null String input
IllegalArgumentException - if padStr is null or empty
Removes one newline from end of a String if it's there, otherwise leave it alone. A newline is "
\n
", "
\r
", or "
\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") = ""
str - the String to chomp a newline from, may be null
null if null String input
Removes
separator
from the end of
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(String, String). This method uses String.endsWith(String).
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"
str - the String to chomp from, may be null
separator - separator String, may be null
null if null String input
Remove the last character from a String.
If the String ends in \r\n, then remove both of 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") = ""
str - the String to chop last character from, may be null
null if null String input
Compare two Strings lexicographically, as per
String.compareTo(String)
, returning :
int = 0, if str1 is equal to str2 (or both null)int < 0, if str1 is less than str2int > 0, if str1 is greater than str2This is a null safe version of :
str1.compareTo(str2)
null value is considered less than non-null value. Two null references are considered equal.
StringUtils.compare(null, null) = 0
StringUtils.compare(null , "a") < 0
StringUtils.compare("a", null) > 0
StringUtils.compare("abc", "abc") = 0
StringUtils.compare("a", "b") < 0
StringUtils.compare("b", "a") > 0
StringUtils.compare("a", "B") > 0
StringUtils.compare("ab", "abc") < 0
str1 - the String to compare from
str2 - the String to compare to
str1 is respectively less, equal or greater than str2
Compare two Strings lexicographically, as per
String.compareTo(String)
, returning :
int = 0, if str1 is equal to str2 (or both null)int < 0, if str1 is less than str2int > 0, if str1 is greater than str2This is a null safe version of :
str1.compareTo(str2)
null inputs are handled according to the nullIsLess parameter. Two null references are considered equal.
StringUtils.compare(null, null, *) = 0
StringUtils.compare(null , "a", true) < 0
StringUtils.compare(null , "a", false) > 0
StringUtils.compare("a", null, true) > 0
StringUtils.compare("a", null, false) < 0
StringUtils.compare("abc", "abc", *) = 0
StringUtils.compare("a", "b", *) < 0
StringUtils.compare("b", "a", *) > 0
StringUtils.compare("a", "B", *) > 0
StringUtils.compare("ab", "abc", *) < 0
str1 - the String to compare from
str2 - the String to compare to
nullIsLess - whether consider null value less than non-null value
str1 is respectively less, equal ou greater than str2
Compare two Strings lexicographically, ignoring case differences, as per
String.compareToIgnoreCase(String)
, returning :
int = 0, if str1 is equal to str2 (or both null)int < 0, if str1 is less than str2int > 0, if str1 is greater than str2This is a null safe version of :
str1.compareToIgnoreCase(str2)
null value is considered less than non-null value. Two null references are considered equal. Comparison is case insensitive.
StringUtils.compareIgnoreCase(null, null) = 0
StringUtils.compareIgnoreCase(null , "a") < 0
StringUtils.compareIgnoreCase("a", null) > 0
StringUtils.compareIgnoreCase("abc", "abc") = 0
StringUtils.compareIgnoreCase("abc", "ABC") = 0
StringUtils.compareIgnoreCase("a", "b") < 0
StringUtils.compareIgnoreCase("b", "a") > 0
StringUtils.compareIgnoreCase("a", "B") < 0
StringUtils.compareIgnoreCase("A", "b") < 0
StringUtils.compareIgnoreCase("ab", "ABC") < 0
str1 - the String to compare from
str2 - the String to compare to
str1 is respectively less, equal ou greater than str2, ignoring case differences.
Compare two Strings lexicographically, ignoring case differences, as per
String.compareToIgnoreCase(String)
, returning :
int = 0, if str1 is equal to str2 (or both null)int < 0, if str1 is less than str2int > 0, if str1 is greater than str2This is a null safe version of :
str1.compareToIgnoreCase(str2)
null inputs are handled according to the nullIsLess parameter. Two null references are considered equal. Comparison is case insensitive.
StringUtils.compareIgnoreCase(null, null, *) = 0
StringUtils.compareIgnoreCase(null , "a", true) < 0
StringUtils.compareIgnoreCase(null , "a", false) > 0
StringUtils.compareIgnoreCase("a", null, true) > 0
StringUtils.compareIgnoreCase("a", null, false) < 0
StringUtils.compareIgnoreCase("abc", "abc", *) = 0
StringUtils.compareIgnoreCase("abc", "ABC", *) = 0
StringUtils.compareIgnoreCase("a", "b", *) < 0
StringUtils.compareIgnoreCase("b", "a", *) > 0
StringUtils.compareIgnoreCase("a", "B", *) < 0
StringUtils.compareIgnoreCase("A", "b", *) < 0
StringUtils.compareIgnoreCase("ab", "abc", *) < 0
str1 - the String to compare from
str2 - the String to compare to
nullIsLess - whether consider null value less than non-null value
str1 is respectively less, equal ou greater than str2, ignoring case differences.
Tests if CharSequence contains a search CharSequence, handling
null
. This method uses
String.indexOf(String)
if possible.
A null CharSequence will return 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
seq - the CharSequence to check, may be null
searchSeq - the CharSequence to find, may be null
null string input
Tests if CharSequence contains a search character, handling
null
. This method uses
String.indexOf(int)
if possible.
A null or empty ("") CharSequence will return false.
StringUtils.contains(null, *) = false
StringUtils.contains("", *) = false
StringUtils.contains("abc", 'a') = true
StringUtils.contains("abc", 'z') = false
seq - the CharSequence to check, may be null
searchChar - the character to find
null string input
Tests if the CharSequence contains any character in the given set of characters.
A null CharSequence will return false. A null or zero length search array will return 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("zzabyycdxx", ['z', 'y']) = true
StringUtils.containsAny("aba", ['z']) = false
cs - the CharSequence to check, may be null
searchChars - the chars to search for, may be null
true if any of the chars are found, false if no match or null input
Tests if the CharSequence contains any character in the given set of characters.
A null CharSequence will return false. A null search CharSequence will return 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("zzabyycdxx", "zy") = true
StringUtils.containsAny("zzabyycdxx", "\tx") = true
StringUtils.containsAny("zzabyycdxx", "$.#yF") = true
StringUtils.containsAny("aba", "z") = false
cs - the CharSequence to check, may be null
searchChars - the chars to search for, may be null
true if any of the chars are found, false if no match or null input
Tests if the CharSequence contains any of the CharSequences in the given array.
A null cs CharSequence will return false. A null or zero length search array will return false.
StringUtils.containsAny(null, *) = false
StringUtils.containsAny("", *) = false
StringUtils.containsAny(*, null) = false
StringUtils.containsAny(*, []) = false
StringUtils.containsAny("abcd", "ab", null) = true
StringUtils.containsAny("abcd", "ab", "cd") = true
StringUtils.containsAny("abc", "d", "abc") = true
cs - The CharSequence to check, may be null
searchCharSequences - The array of CharSequences to search for, may be null. Individual CharSequences may be null as well.
true if any of the search CharSequences are found, false otherwise
Tests if the CharSequence contains any of the CharSequences in the given array, ignoring case.
A null cs CharSequence will return false. A null or zero length search array will return false.
StringUtils.containsAny(null, *) = false
StringUtils.containsAny("", *) = false
StringUtils.containsAny(*, null) = false
StringUtils.containsAny(*, []) = false
StringUtils.containsAny("abcd", "ab", null) = true
StringUtils.containsAny("abcd", "ab", "cd") = true
StringUtils.containsAny("abc", "d", "abc") = true
StringUtils.containsAny("abc", "D", "ABC") = true
StringUtils.containsAny("ABC", "d", "abc") = true
cs - The CharSequence to check, may be null
searchCharSequences - The array of CharSequences to search for, may be null. Individual CharSequences may be null as well.
true if any of the search CharSequences are found, false otherwise
Tests if CharSequence contains a search CharSequence irrespective of case, handling
null
. Case-insensitivity is defined as by
String.equalsIgnoreCase(String)
.
A null CharSequence will return false.
StringUtils.containsIgnoreCase(null, *) = false
StringUtils.containsIgnoreCase(*, null) = false
StringUtils.containsIgnoreCase("", "") = true
StringUtils.containsIgnoreCase("abc", "") = true
StringUtils.containsIgnoreCase("abc", "a") = true
StringUtils.containsIgnoreCase("abc", "z") = false
StringUtils.containsIgnoreCase("abc", "A") = true
StringUtils.containsIgnoreCase("abc", "Z") = false
str - the CharSequence to check, may be null
searchStr - the CharSequence to find, may be null
null string input
Tests that the CharSequence does not contain certain characters.
A null CharSequence will return true. A null invalid character array will return 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
cs - the CharSequence to check, may be null
searchChars - an array of invalid chars, may be null
Tests that the CharSequence does not contain certain characters.
A null CharSequence will return true. A null invalid character array will return 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
cs - the CharSequence to check, may be null
invalidChars - a String of invalid chars, may be null
Tests if the CharSequence contains only certain characters.
A null CharSequence will return false. A null valid character array will return false. An empty CharSequence (length()=0) always returns 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
cs - the String to check, may be null
valid - an array of valid chars, may be null
Tests if the CharSequence contains only certain characters.
A null CharSequence will return false. A null valid character String will return false. An empty String (length()=0) always returns 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
cs - the CharSequence to check, may be null
validChars - a String of valid chars, may be null
Tests whether the given CharSequence contains any whitespace characters.
Whitespace is defined by Character.isWhitespace(char).
StringUtils.containsWhitespace(null) = false
StringUtils.containsWhitespace("") = false
StringUtils.containsWhitespace("ab") = false
StringUtils.containsWhitespace(" ab") = true
StringUtils.containsWhitespace("a b") = true
StringUtils.containsWhitespace("ab ") = true
seq - the CharSequence to check (may be null)
true if the CharSequence is not empty and contains at least 1 (breaking) whitespace character
Counts how many times the char appears in the given string.
A null or empty ("") String input returns 0.
StringUtils.countMatches(null, *) = 0
StringUtils.countMatches("", *) = 0
StringUtils.countMatches("abba", 0) = 0
StringUtils.countMatches("abba", 'a') = 2
StringUtils.countMatches("abba", 'b') = 2
StringUtils.countMatches("abba", 'x') = 0
str - the CharSequence to check, may be null
ch - the char to count
null
Counts how many times the substring appears in the larger string. Note that the code only counts non-overlapping matches.
A null or empty ("") String input returns 0.
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
StringUtils.countMatches("ababa", "aba") = 1
str - the CharSequence to check, may be null
sub - the substring to count, may be null
null
Returns either the passed in CharSequence, or if the CharSequence is
blank
(whitespaces, empty (
""
) or
null
), the value of
defaultStr
.
Whitespace is defined by Character.isWhitespace(char).
StringUtils.defaultIfBlank(null, "NULL") = "NULL"
StringUtils.defaultIfBlank("", "NULL") = "NULL"
StringUtils.defaultIfBlank(" ", "NULL") = "NULL"
StringUtils.defaultIfBlank("bat", "NULL") = "bat"
StringUtils.defaultIfBlank("", null) = null
T - the specific kind of CharSequence
str - the CharSequence to check, may be null
defaultStr - the default CharSequence to return if str is blank (whitespaces, empty ("") or null); may be null
Returns either the passed in CharSequence, or if the CharSequence is empty or
null
, the value of
defaultStr
.
StringUtils.defaultIfEmpty(null, "NULL") = "NULL"
StringUtils.defaultIfEmpty("", "NULL") = "NULL"
StringUtils.defaultIfEmpty(" ", "NULL") = " "
StringUtils.defaultIfEmpty("bat", "NULL") = "bat"
StringUtils.defaultIfEmpty("", null) = null
T - the specific kind of CharSequence
str - the CharSequence to check, may be null
defaultStr - the default CharSequence to return if the input is empty ("") or null, may be null
Returns either the passed in String, or if the String is
null
, an empty String ("").
StringUtils.defaultString(null) = ""
StringUtils.defaultString("") = ""
StringUtils.defaultString("bat") = "bat"
str - the String to check, may be null
null
Returns either the given String, or if the String is
null
,
nullDefault
.
StringUtils.defaultString(null, "NULL") = "NULL"
StringUtils.defaultString("", "NULL") = ""
StringUtils.defaultString("bat", "NULL") = "bat"
Since this is now provided by Java, instead call Objects.toString(Object, String):
Objects.toString(null, "NULL") = "NULL"
Objects.toString("", "NULL") = ""
Objects.toString("bat", "NULL") = "bat"
str - the String to check, may be null
nullDefault - the default String to return if the input is null, may be null
null
Deletes all whitespaces from a String as defined by
Character.isWhitespace(char)
.
StringUtils.deleteWhitespace(null) = null
StringUtils.deleteWhitespace("") = ""
StringUtils.deleteWhitespace("abc") = "abc"
StringUtils.deleteWhitespace(" ab c ") = "abc"
str - the String to delete whitespace from, may be null
null if null String input
Compares two Strings, and returns the portion where they differ. More precisely, return the remainder of the second String, starting from where it's different from the first. This means that the difference between "abc" and "ab" is the empty String and not "c".
For example, 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("abc", "ab") = ""
StringUtils.difference("ab", "abxyz") = "xyz"
StringUtils.difference("abcde", "abxyz") = "xyz"
StringUtils.difference("abcde", "xyz") = "xyz"
str1 - the first String, may be null
str2 - the second String, may be null
Tests if a CharSequence ends with a specified suffix.
nulls are handled without exceptions. Two 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
StringUtils.endsWith("ABCDEF", "") = true
str - the CharSequence to check, may be null
suffix - the suffix to find, may be null
true if the CharSequence ends with the suffix, case-sensitive, or both null
Tests if a CharSequence ends with any of the provided case-sensitive suffixes.
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
StringUtils.endsWithAny("abcXYZ", "def", "XYZ") = true
StringUtils.endsWithAny("abcXYZ", "def", "xyz") = false
sequence - the CharSequence to check, may be null
searchStrings - the case-sensitive CharSequences to find, may be empty or contain null
true if the input sequence is null AND no searchStrings are provided, or the input sequence ends in any of the provided case-sensitive searchStrings.
Case-insensitive check if a CharSequence ends with a specified suffix.
nulls are handled without exceptions. Two 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
str - the CharSequence to check, may be null
suffix - the suffix to find, may be null
true if the CharSequence ends with the suffix, case-insensitive, or both null
Compares two CharSequences, returning
true
if they represent equal sequences of characters.
nulls are handled without exceptions. Two 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
cs1 - the first CharSequence, may be null
cs2 - the second CharSequence, may be null
true if the CharSequences are equal (case-sensitive), or both null
Compares given
string
to a CharSequences vararg of
searchStrings
, returning
true
if the
string
is equal to any of the
searchStrings
.
StringUtils.equalsAny(null, (CharSequence[]) null) = false
StringUtils.equalsAny(null, null, null) = true
StringUtils.equalsAny(null, "abc", "def") = false
StringUtils.equalsAny("abc", null, "def") = false
StringUtils.equalsAny("abc", "abc", "def") = true
StringUtils.equalsAny("abc", "ABC", "DEF") = false
string - to compare, may be null.
searchStrings - a vararg of strings, may be null.
true if the string is equal (case-sensitive) to any other element of searchStrings; false if searchStrings is null or contains no matches.
Compares given
string
to a CharSequences vararg of
searchStrings
, returning
true
if the
string
is equal to any of the
searchStrings
, ignoring case.
StringUtils.equalsAnyIgnoreCase(null, (CharSequence[]) null) = false
StringUtils.equalsAnyIgnoreCase(null, null, null) = true
StringUtils.equalsAnyIgnoreCase(null, "abc", "def") = false
StringUtils.equalsAnyIgnoreCase("abc", null, "def") = false
StringUtils.equalsAnyIgnoreCase("abc", "abc", "def") = true
StringUtils.equalsAnyIgnoreCase("abc", "ABC", "DEF") = true
string - to compare, may be null.
searchStrings - a vararg of strings, may be null.
true if the string is equal (case-insensitive) to any other element of searchStrings; false if searchStrings is null or contains no matches.
Compares two CharSequences, returning
true
if they represent equal sequences of characters, ignoring case.
nulls are handled without exceptions. Two null references are considered equal. The 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
cs1 - the first CharSequence, may be null
cs2 - the second CharSequence, may be null
true if the CharSequences are equal (case-insensitive), or both null
Returns the first value in the array which is not empty (""),
null
or whitespace only.
Whitespace is defined by Character.isWhitespace(char).
If all values are blank or the array is null or empty then null is returned.
StringUtils.firstNonBlank(null, null, null) = null
StringUtils.firstNonBlank(null, "", " ") = null
StringUtils.firstNonBlank("abc") = "abc"
StringUtils.firstNonBlank(null, "xyz") = "xyz"
StringUtils.firstNonBlank(null, "", " ", "xyz") = "xyz"
StringUtils.firstNonBlank(null, "xyz", "abc") = "xyz"
StringUtils.firstNonBlank() = null
T - the specific kind of CharSequence
values - the values to test, may be null or empty
values which is not blank, or null if there are no non-blank values
Returns the first value in the array which is not empty.
If all values are empty or the array is null or empty then null is returned.
StringUtils.firstNonEmpty(null, null, null) = null
StringUtils.firstNonEmpty(null, null, "") = null
StringUtils.firstNonEmpty(null, "", " ") = " "
StringUtils.firstNonEmpty("abc") = "abc"
StringUtils.firstNonEmpty(null, "xyz") = "xyz"
StringUtils.firstNonEmpty("", "xyz") = "xyz"
StringUtils.firstNonEmpty(null, "xyz", "abc") = "xyz"
StringUtils.firstNonEmpty() = null
T - the specific kind of CharSequence
values - the values to test, may be null or empty
values which is not empty, or null if there are no non-empty values
string - input string
charset - The Charset to encode the String. If null, then use the default Charset.
string is null, the result of String.getBytes(Charset) otherwise.
string - input string
charset - The Charset name to encode the String. If null, then use the default Charset.
string is null, the result of String.getBytes(String) otherwise.
UnsupportedEncodingException - Thrown when the named charset is not supported.
Compares all Strings in an array and returns the initial sequence of characters 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 "
strs - array of String objects, entries may be null
Checks if a String
str
contains Unicode digits, if yes then concatenate all the digits in
str
and return it as a String.
An empty ("") String will be returned if no digits found in str.
StringUtils.getDigits(null) = null
StringUtils.getDigits("") = ""
StringUtils.getDigits("abc") = ""
StringUtils.getDigits("1000$") = "1000"
StringUtils.getDigits("1123~45") = "112345"
StringUtils.getDigits("(541) 754-3010") = "5417543010"
StringUtils.getDigits("१२३") = "१२३"
str - the String to extract digits from, may be null
null String if str is null
Find the Fuzzy Distance which indicates the similarity score between two Strings.
This string matching algorithm is similar to the algorithms of editors such as Sublime Text, TextMate, Atom and others. One point is given for every matched character. Subsequent matches yield two bonus points. A higher score indicates a higher similarity.
StringUtils.getFuzzyDistance(null, null, null) = IllegalArgumentException
StringUtils.getFuzzyDistance("", "", Locale.ENGLISH) = 0
StringUtils.getFuzzyDistance("Workshop", "b", Locale.ENGLISH) = 0
StringUtils.getFuzzyDistance("Room", "o", Locale.ENGLISH) = 1
StringUtils.getFuzzyDistance("Workshop", "w", Locale.ENGLISH) = 1
StringUtils.getFuzzyDistance("Workshop", "ws", Locale.ENGLISH) = 2
StringUtils.getFuzzyDistance("Workshop", "wo", Locale.ENGLISH) = 4
StringUtils.getFuzzyDistance("Apache Software Foundation", "asf", Locale.ENGLISH) = 3
term - a full term that should be matched against, must not be null
query - the query that will be matched against a term, must not be null
locale - This string matching logic is case-insensitive. A locale is necessary to normalize both Strings to lower case.
IllegalArgumentException - if either String input null or Locale input null
Returns either the passed in CharSequence, or if the CharSequence is
blank
(whitespaces, empty (
""
) or
null
), the value supplied by
defaultStrSupplier
.
Whitespace is defined by Character.isWhitespace(char).
Caller responsible for thread-safety and exception handling of default value supplier
StringUtils.getIfBlank(null, () -> "NULL") = "NULL"
StringUtils.getIfBlank("", () -> "NULL") = "NULL"
StringUtils.getIfBlank(" ", () -> "NULL") = "NULL"
StringUtils.getIfBlank("bat", () -> "NULL") = "bat"
StringUtils.getIfBlank("", () -> null) = null
StringUtils.getIfBlank("", null) = null
T - the specific kind of CharSequence
str - the CharSequence to check, may be null
defaultSupplier - the supplier of default CharSequence to return if the input is blank (whitespaces, empty ("") or null); may be null
Returns either the passed in CharSequence, or if the CharSequence is empty or
null
, the value supplied by
defaultStrSupplier
.
Caller responsible for thread-safety and exception handling of default value supplier
StringUtils.getIfEmpty(null, () -> "NULL") = "NULL"
StringUtils.getIfEmpty("", () -> "NULL") = "NULL"
StringUtils.getIfEmpty(" ", () -> "NULL") = " "
StringUtils.getIfEmpty("bat", () -> "NULL") = "bat"
StringUtils.getIfEmpty("", () -> null) = null
StringUtils.getIfEmpty("", null) = null
T - the specific kind of CharSequence
str - the CharSequence to check, may be null
defaultSupplier - the supplier of default CharSequence to return if the input is empty ("") or null, may be null
Find the Jaro Winkler Distance which indicates the similarity score between two Strings.
The Jaro measure is the weighted sum of percentage of matched characters from each file and transposed characters. Winkler increased this measure for matching initial characters.
This implementation is based on the Jaro Winkler similarity algorithm from https://en.wikipedia.org/wiki/Jaro%E2%80%93Winkler_distance.
StringUtils.getJaroWinklerDistance(null, null) = IllegalArgumentException
StringUtils.getJaroWinklerDistance("", "") = 0.0
StringUtils.getJaroWinklerDistance("", "a") = 0.0
StringUtils.getJaroWinklerDistance("aaapppp", "") = 0.0
StringUtils.getJaroWinklerDistance("frog", "fog") = 0.93
StringUtils.getJaroWinklerDistance("fly", "ant") = 0.0
StringUtils.getJaroWinklerDistance("elephant", "hippo") = 0.44
StringUtils.getJaroWinklerDistance("hippo", "elephant") = 0.44
StringUtils.getJaroWinklerDistance("hippo", "zzzzzzzz") = 0.0
StringUtils.getJaroWinklerDistance("hello", "hallo") = 0.88
StringUtils.getJaroWinklerDistance("ABC Corporation", "ABC Corp") = 0.93
StringUtils.getJaroWinklerDistance("D N H Enterprises Inc", "D & H Enterprises, Inc.") = 0.95
StringUtils.getJaroWinklerDistance("My Gym Children's Fitness Center", "My Gym. Childrens Fitness") = 0.92
StringUtils.getJaroWinklerDistance("PENNSYLVANIA", "PENNCISYLVNIA") = 0.88
first - the first String, must not be null
second - the second String, must not be null
IllegalArgumentException - if either String input null
Find the Levenshtein distance between two Strings.
This is the number of changes needed to change one String into another, where each change is a single character modification (deletion, insertion or substitution).
The implementation uses a single-dimensional array of length s.length() + 1. See https://blog.softwx.net/2014/12/optimizing-levenshtein-algorithm-in-c.html for details.
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
s - the first String, must not be null
t - the second String, must not be null
IllegalArgumentException - if either String input null
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 into another, where each change is a single character modification (deletion, insertion or substitution).
This implementation follows from Algorithms on Strings, Trees and Sequences by Dan Gusfield and Chas Emerick's implementation of the Levenshtein distance algorithm from http://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
s - the first String, must not be null
t - the second String, must not be null
threshold - the target threshold, must not be negative
-1 if the distance would be greater than the threshold
IllegalArgumentException - if either String input null or negative threshold
Finds the first index within a CharSequence, handling
null
. This method uses
String.indexOf(String, int)
if possible.
A null CharSequence will return -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
seq - the CharSequence to check, may be null
searchSeq - the CharSequence to find, may be null
null string input
Finds the first index within a CharSequence, handling
null
. This method uses
String.indexOf(String, int)
if possible.
A null CharSequence will return -1. A negative start position is treated as zero. An empty ("") search CharSequence always matches. A start position greater than the string length only matches an empty search CharSequence.
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
seq - the CharSequence to check, may be null
searchSeq - the CharSequence to find, may be null
startPos - the start position, negative treated as zero
null string input
Returns the index within
seq
of the first occurrence of the specified character. If a character with value
searchChar
occurs in the character sequence represented by
seq CharSequence
object, then the index (in Unicode code units) of the first such occurrence is returned. For values of
searchChar
in the range from 0 to 0xFFFF (inclusive), this is the smallest value
ksuch that:
this.charAt(k) == searchChar
is true. For other values of
searchChar
, it is the smallest value
ksuch that:
this.codePointAt(k) == searchChar
is true. In either case, if no such character occurs in
seq
, then
INDEX_NOT_FOUND (-1)
is returned.
Furthermore, a null or empty ("") CharSequence will return INDEX_NOT_FOUND (-1).
StringUtils.indexOf(null, *) = -1
StringUtils.indexOf("", *) = -1
StringUtils.indexOf("aabaabaa", 'a') = 0
StringUtils.indexOf("aabaabaa", 'b') = 2
StringUtils.indexOf("aaaaaaaa", 'Z') = -1
seq - the CharSequence to check, may be null
searchChar - the character to find
null string input
CharSequenceUtils call to behave more like String
Returns the index within
seq
of the first occurrence of the specified character, starting the search at the specified index.
If a character with value searchChar occurs in the character sequence represented by the seq CharSequence object at an index no smaller than startPos, then the index of the first such occurrence is returned. For values of searchChar in the range from 0 to 0xFFFF (inclusive), this is the smallest value k such that:
(this.charAt(k) == searchChar) && (k >= startPos)
is true. For other values of
searchChar
, it is the smallest value
ksuch that:
(this.codePointAt(k) == searchChar) && (k >= startPos)
is true. In either case, if no such character occurs in
seq
at or after position
startPos
, then
-1
is returned.
There is no restriction on the value of startPos. If it is negative, it has the same effect as if it were zero: this entire string may be searched. If it is greater than the length of this string, it has the same effect as if it were equal to the length of this string: (INDEX_NOT_FOUND) -1 is returned. Furthermore, a null or empty ("") CharSequence will return (INDEX_NOT_FOUND) -1.
All indices are specified in char values (Unicode code units).
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
seq - the CharSequence to check, may be null
searchChar - the character to find
startPos - the start position, negative treated as zero
null string input
CharSequenceUtils call to behave more like String
Search a CharSequence to find the first index of any character in the given set of characters.
A null String will return -1. A null or zero length search array will return -1.
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
cs - the CharSequence to check, may be null
searchChars - the chars to search for, may be null
Find the first index of any of a set of potential substrings.
A null CharSequence will return -1. A null or zero length search array will return -1. A null search array entry will be ignored, but a search array containing "" will return 0 if str is not null. This method uses String.indexOf(String) 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
str - the CharSequence to check, may be null
searchStrs - the CharSequences to search for, may be null
Search a CharSequence to find the first index of any character in the given set of characters.
A null String will return -1. A null search string will return -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
cs - the CharSequence to check, may be null
searchChars - the chars to search for, may be null
Searches a CharSequence to find the first index of any character not in the given set of characters, i.e., find index i of first char in cs such that (cs.codePointAt(i) ∉ { x ∈ codepoints(searchChars) })
A null CharSequence will return -1. A null or zero length search array will return -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
cs - the CharSequence to check, may be null
searchChars - the chars to search for, may be null
Search a CharSequence to find the first index of any character not in the given set of characters, i.e., find index i of first char in seq such that (seq.codePointAt(i) ∉ { x ∈ codepoints(searchChars) })
A null CharSequence will return -1. A null or empty search string will return -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
seq - the CharSequence to check, may be null
searchChars - the chars to search for, may be null
Compares all CharSequences in an array and returns the index at which the CharSequences begin to differ.
For example, indexOfDifference(new String[] {"i am a machine", "i am a robot"}) -> 7
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
css - array of CharSequences, entries may be null
Compares two CharSequences, and returns the index at which the CharSequences begin to differ.
For example, 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
cs1 - the first CharSequence, may be null
cs2 - the second CharSequence, may be null
Case in-sensitive find of the first index within a CharSequence.
A null CharSequence will return -1. A negative start position is treated as zero. An empty ("") search CharSequence always matches. A start position greater than the string length only matches an empty search CharSequence.
StringUtils.indexOfIgnoreCase(null, *) = -1
StringUtils.indexOfIgnoreCase(*, null) = -1
StringUtils.indexOfIgnoreCase("", "") = 0
StringUtils.indexOfIgnoreCase(" ", " ") = 0
StringUtils.indexOfIgnoreCase("aabaabaa", "a") = 0
StringUtils.indexOfIgnoreCase("aabaabaa", "b") = 2
StringUtils.indexOfIgnoreCase("aabaabaa", "ab") = 1
str - the CharSequence to check, may be null
searchStr - the CharSequence to find, may be null
null string input
Case in-sensitive find of the first index within a CharSequence from the specified position.
A null CharSequence will return -1. A negative start position is treated as zero. An empty ("") search CharSequence always matches. A start position greater than the string length only matches an empty search CharSequence.
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) = -1
str - the CharSequence to check, may be null
searchStr - the CharSequence to find, may be null
startPos - the start position, negative treated as zero
null string input
Tests if all of the CharSequences are empty (""), null or whitespace only.
Whitespace is defined by Character.isWhitespace(char).
StringUtils.isAllBlank(null) = true
StringUtils.isAllBlank(null, "foo") = false
StringUtils.isAllBlank(null, null) = true
StringUtils.isAllBlank("", "bar") = false
StringUtils.isAllBlank("bob", "") = false
StringUtils.isAllBlank(" bob ", null) = false
StringUtils.isAllBlank(" ", "bar") = false
StringUtils.isAllBlank("foo", "bar") = false
StringUtils.isAllBlank(new String[] {}) = true
css - the CharSequences to check, may be null or empty
true if all of the CharSequences are empty or null or whitespace only
Tests if all of the CharSequences are empty ("") or null.
StringUtils.isAllEmpty(null) = true
StringUtils.isAllEmpty(null, "") = true
StringUtils.isAllEmpty(new String[] {}) = true
StringUtils.isAllEmpty(null, "foo") = false
StringUtils.isAllEmpty("", "bar") = false
StringUtils.isAllEmpty("bob", "") = false
StringUtils.isAllEmpty(" bob ", null) = false
StringUtils.isAllEmpty(" ", "bar") = false
StringUtils.isAllEmpty("foo", "bar") = false
css - the CharSequences to check, may be null or empty
true if all of the CharSequences are empty or null
Tests if the CharSequence contains only lowercase characters.
null will return false. An empty CharSequence (length()=0) will return false.
StringUtils.isAllLowerCase(null) = false
StringUtils.isAllLowerCase("") = false
StringUtils.isAllLowerCase(" ") = false
StringUtils.isAllLowerCase("abc") = true
StringUtils.isAllLowerCase("abC") = false
StringUtils.isAllLowerCase("ab c") = false
StringUtils.isAllLowerCase("ab1c") = false
StringUtils.isAllLowerCase("ab/c") = false
cs - the CharSequence to check, may be null
true if only contains lowercase characters, and is non-null
Tests if the CharSequence contains only uppercase characters.
null will return false. An empty String (length()=0) will return false.
StringUtils.isAllUpperCase(null) = false
StringUtils.isAllUpperCase("") = false
StringUtils.isAllUpperCase(" ") = false
StringUtils.isAllUpperCase("ABC") = true
StringUtils.isAllUpperCase("aBC") = false
StringUtils.isAllUpperCase("A C") = false
StringUtils.isAllUpperCase("A1C") = false
StringUtils.isAllUpperCase("A/C") = false
cs - the CharSequence to check, may be null
true if only contains uppercase characters, and is non-null
Tests if the CharSequence contains only Unicode letters.
null will return false. An empty CharSequence (length()=0) will return false.
StringUtils.isAlpha(null) = false
StringUtils.isAlpha("") = false
StringUtils.isAlpha(" ") = false
StringUtils.isAlpha("abc") = true
StringUtils.isAlpha("ab2c") = false
StringUtils.isAlpha("ab-c") = false
cs - the CharSequence to check, may be null
true if only contains letters, and is non-null
Tests if the CharSequence contains only Unicode letters or digits.
null will return false. An empty CharSequence (length()=0) will return 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
cs - the CharSequence to check, may be null
true if only contains letters or digits, and is non-null
Tests if the CharSequence contains only Unicode letters, digits or space (
' '
).
null will return false. An empty CharSequence (length()=0) will return 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
cs - the CharSequence to check, may be null
true if only contains letters, digits or space, and is non-null
Tests if the CharSequence contains only Unicode letters and space (' ').
null will return false An empty CharSequence (length()=0) will return 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
cs - the CharSequence to check, may be null
true if only contains letters and space, and is non-null
Tests if any of the CharSequences are
blank
(whitespaces, empty (
""
) or
null
).
Whitespace is defined by Character.isWhitespace(char).
StringUtils.isAnyBlank((String) null) = true
StringUtils.isAnyBlank((String[]) null) = false
StringUtils.isAnyBlank(null, "foo") = true
StringUtils.isAnyBlank(null, null) = true
StringUtils.isAnyBlank("", "bar") = true
StringUtils.isAnyBlank("bob", "") = true
StringUtils.isAnyBlank(" bob ", null) = true
StringUtils.isAnyBlank(" ", "bar") = true
StringUtils.isAnyBlank(new String[] {}) = false
StringUtils.isAnyBlank(new String[]{""}) = true
StringUtils.isAnyBlank("foo", "bar") = false
css - the CharSequences to check, may be null or empty
true if any of the CharSequences are blank (whitespaces, empty ("") or null)
Tests if any of the CharSequences are empty ("") or null.
StringUtils.isAnyEmpty((String) null) = true
StringUtils.isAnyEmpty((String[]) null) = false
StringUtils.isAnyEmpty(null, "foo") = true
StringUtils.isAnyEmpty("", "bar") = true
StringUtils.isAnyEmpty("bob", "") = true
StringUtils.isAnyEmpty(" bob ", null) = true
StringUtils.isAnyEmpty(" ", "bar") = false
StringUtils.isAnyEmpty("foo", "bar") = false
StringUtils.isAnyEmpty(new String[]{}) = false
StringUtils.isAnyEmpty(new String[]{""}) = true
css - the CharSequences to check, may be null or empty
true if any of the CharSequences are empty or null
Tests if the CharSequence contains only ASCII printable characters.
null will return false. An empty CharSequence (length()=0) will return 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(" ") = true
StringUtils.isAsciiPrintable("!") = true
StringUtils.isAsciiPrintable("~") = true
StringUtils.isAsciiPrintable("") = false
StringUtils.isAsciiPrintable("Ceki Gülcü") = false
cs - the CharSequence to check, may be null
true if every character is in the range 32 through 126
Tests if a CharSequence is empty (
"")
, null, or contains only whitespace as defined by
Character.isWhitespace(char)
.
StringUtils.isBlank(null) = true
StringUtils.isBlank("") = true
StringUtils.isBlank(" ") = true
StringUtils.isBlank("bob") = false
StringUtils.isBlank(" bob ") = false
cs - the CharSequence to check, may be null
true if the CharSequence is null, empty or whitespace only
Tests 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().
cs - the CharSequence to check, may be null
true if the CharSequence is empty or null
Tests if the CharSequence contains mixed casing of both uppercase and lowercase characters.
null will return false. An empty CharSequence (length()=0) will return false.
StringUtils.isMixedCase(null) = false
StringUtils.isMixedCase("") = false
StringUtils.isMixedCase(" ") = false
StringUtils.isMixedCase("ABC") = false
StringUtils.isMixedCase("abc") = false
StringUtils.isMixedCase("aBc") = true
StringUtils.isMixedCase("A c") = true
StringUtils.isMixedCase("A1c") = true
StringUtils.isMixedCase("a/C") = true
StringUtils.isMixedCase("aC\t") = true
cs - the CharSequence to check, may be null
true if the CharSequence contains both uppercase and lowercase characters
Tests if none of the CharSequences are empty (""), null or whitespace only.
Whitespace is defined by Character.isWhitespace(char).
StringUtils.isNoneBlank((String) null) = false
StringUtils.isNoneBlank((String[]) null) = true
StringUtils.isNoneBlank(null, "foo") = false
StringUtils.isNoneBlank(null, null) = false
StringUtils.isNoneBlank("", "bar") = false
StringUtils.isNoneBlank("bob", "") = false
StringUtils.isNoneBlank(" bob ", null) = false
StringUtils.isNoneBlank(" ", "bar") = false
StringUtils.isNoneBlank(new String[] {}) = true
StringUtils.isNoneBlank(new String[]{""}) = false
StringUtils.isNoneBlank("foo", "bar") = true
css - the CharSequences to check, may be null or empty
true if none of the CharSequences are empty or null or whitespace only
Tests if none of the CharSequences are empty ("") or null.
StringUtils.isNoneEmpty((String) null) = false
StringUtils.isNoneEmpty((String[]) null) = true
StringUtils.isNoneEmpty(null, "foo") = false
StringUtils.isNoneEmpty("", "bar") = false
StringUtils.isNoneEmpty("bob", "") = false
StringUtils.isNoneEmpty(" bob ", null) = false
StringUtils.isNoneEmpty(new String[] {}) = true
StringUtils.isNoneEmpty(new String[]{""}) = false
StringUtils.isNoneEmpty(" ", "bar") = true
StringUtils.isNoneEmpty("foo", "bar") = true
css - the CharSequences to check, may be null or empty
true if none of the CharSequences are empty or null
Tests if a CharSequence is not
blank
(whitespaces, empty (
""
) or
null
).
Whitespace is defined by Character.isWhitespace(char).
StringUtils.isNotBlank(null) = false
StringUtils.isNotBlank("") = false
StringUtils.isNotBlank(" ") = false
StringUtils.isNotBlank("bob") = true
StringUtils.isNotBlank(" bob ") = true
cs - the CharSequence to check, may be null
true if the CharSequence is not blank (whitespaces, empty ("") or null)
Tests 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
cs - the CharSequence to check, may be null
true if the CharSequence is not empty and not null
Tests if the CharSequence contains only Unicode digits. A decimal point is not a Unicode digit and returns false.
null will return false. An empty CharSequence (length()=0) will return false.
Note that the method does not allow for a leading sign, either positive or negative. Also, if a String passes the numeric test, it may still generate a NumberFormatException when parsed by Integer.parseInt or Long.parseLong, e.g. if the value is outside the range for int or long respectively.
StringUtils.isNumeric(null) = false
StringUtils.isNumeric("") = false
StringUtils.isNumeric(" ") = false
StringUtils.isNumeric("123") = true
StringUtils.isNumeric("१२३") = true
StringUtils.isNumeric("12 3") = false
StringUtils.isNumeric("ab2c") = false
StringUtils.isNumeric("12-3") = false
StringUtils.isNumeric("12.3") = false
StringUtils.isNumeric("-123") = false
StringUtils.isNumeric("+123") = false
cs - the CharSequence to check, may be null
true if only contains digits, and is non-null
Tests if the CharSequence contains only Unicode digits or space (
' '
). A decimal point is not a Unicode digit and returns false.
null will return false. An empty CharSequence (length()=0) will return true.
StringUtils.isNumericSpace(null) = false
StringUtils.isNumericSpace("") = true
StringUtils.isNumericSpace(" ") = true
StringUtils.isNumericSpace("123") = true
StringUtils.isNumericSpace("12 3") = true
StringUtils.isNumericSpace("१२३") = true
StringUtils.isNumericSpace("१२ ३") = true
StringUtils.isNumericSpace("ab2c") = false
StringUtils.isNumericSpace("12-3") = false
StringUtils.isNumericSpace("12.3") = false
cs - the CharSequence to check, may be null
true if only contains digits or space, and is non-null
Tests if the CharSequence contains only whitespace.
Whitespace is defined by Character.isWhitespace(char).
null will return false. An empty CharSequence (length()=0) will return true.
StringUtils.isWhitespace(null) = false
StringUtils.isWhitespace("") = true
StringUtils.isWhitespace(" ") = true
StringUtils.isWhitespace("abc") = false
StringUtils.isWhitespace("ab2c") = false
StringUtils.isWhitespace("ab-c") = false
cs - the CharSequence to check, may be null
true if only contains whitespace, and is non-null
Joins the elements of the provided array into a single String containing the provided list of elements.
No delimiter is added before or after the list. Null objects or empty strings within the array are represented by empty strings.
StringUtils.join(null, *) = null StringUtils.join([], *) = "" StringUtils.join([null], *) = "" StringUtils.join([false, false], ';') = "false;false"
array - the array of values to join together, may be null
delimiter - the separator character to use
null if null array input
Joins the elements of the provided array into a single String containing the provided list of elements.
No delimiter is added before or after the list. Null objects or empty strings within the array are represented by empty strings.
StringUtils.join(null, *) = null StringUtils.join([], *) = "" StringUtils.join([null], *) = "" StringUtils.join([true, false, true], ';') = "true;false;true"
array - the array of values to join together, may be null
delimiter - the separator character to use
startIndex - the first index to start joining from. It is an error to pass in a start index past the end of the array
endIndex - the index to stop joining from (exclusive). It is an error to pass in an end index past the end of the array
null if null array input
Joins the elements of the provided array into a single String containing the provided list of elements.
No delimiter is added before or after the list. Null objects or empty strings within the array are represented by empty strings.
StringUtils.join(null, *) = null StringUtils.join([], *) = "" StringUtils.join([null], *) = "" StringUtils.join([1, 2, 3], ';') = "1;2;3" StringUtils.join([1, 2, 3], null) = "123"
array - the array of values to join together, may be null
delimiter - the separator character to use
null if null array input
Joins the elements of the provided array into a single String containing the provided list of elements.
No delimiter is added before or after the list. Null objects or empty strings within the array are represented by empty strings.
StringUtils.join(null, *) = null StringUtils.join([], *) = "" StringUtils.join([null], *) = "" StringUtils.join([1, 2, 3], ';') = "1;2;3" StringUtils.join([1, 2, 3], null) = "123"
array - the array of values to join together, may be null
delimiter - the separator character to use
startIndex - the first index to start joining from. It is an error to pass in a start index past the end of the array
endIndex - the index to stop joining from (exclusive). It is an error to pass in an end index past the end of the array
null if null array input
Joins the elements of the provided array into a single String containing the provided list of elements.
No delimiter is added before or after the list. Null objects or empty strings within the array are represented by empty strings.
StringUtils.join(null, *) = null StringUtils.join([], *) = "" StringUtils.join([null], *) = "" StringUtils.join([1, 2, 3], ';') = "1;2;3" StringUtils.join([1, 2, 3], null) = "123"
array - the array of values to join together, may be null
delimiter - the separator character to use
null if null array input
Joins the elements of the provided array into a single String containing the provided list of elements.
No delimiter is added before or after the list. Null objects or empty strings within the array are represented by empty strings.
StringUtils.join(null, *) = null StringUtils.join([], *) = "" StringUtils.join([null], *) = "" StringUtils.join([1, 2, 3], ';') = "1;2;3" StringUtils.join([1, 2, 3], null) = "123"
array - the array of values to join together, may be null
delimiter - the separator character to use
startIndex - the first index to start joining from. It is an error to pass in a start index past the end of the array
endIndex - the index to stop joining from (exclusive). It is an error to pass in an end index past the end of the array
null if null array input
Joins the elements of the provided array into a single String containing the provided list of elements.
No delimiter is added before or after the list. Null objects or empty strings within the array are represented by empty strings.
StringUtils.join(null, *) = null StringUtils.join([], *) = "" StringUtils.join([null], *) = "" StringUtils.join([1, 2, 3], ';') = "1;2;3" StringUtils.join([1, 2, 3], null) = "123"
array - the array of values to join together, may be null
delimiter - the separator character to use
null if null array input
Joins the elements of the provided array into a single String containing the provided list of elements.
No delimiter is added before or after the list. Null objects or empty strings within the array are represented by empty strings.
StringUtils.join(null, *) = null StringUtils.join([], *) = "" StringUtils.join([null], *) = "" StringUtils.join([1, 2, 3], ';') = "1;2;3" StringUtils.join([1, 2, 3], null) = "123"
array - the array of values to join together, may be null
delimiter - the separator character to use
startIndex - the first index to start joining from. It is an error to pass in a start index past the end of the array
endIndex - the index to stop joining from (exclusive). It is an error to pass in an end index past the end of the array
null if null array input
Joins the elements of the provided array into a single String containing the provided list of elements.
No delimiter is added before or after the list. Null objects or empty strings within the array are represented by empty strings.
StringUtils.join(null, *) = null StringUtils.join([], *) = "" StringUtils.join([null], *) = "" StringUtils.join([1, 2, 3], ';') = "1;2;3" StringUtils.join([1, 2, 3], null) = "123"
array - the array of values to join together, may be null
delimiter - the separator character to use
null if null array input
Joins the elements of the provided array into a single String containing the provided list of elements.
No delimiter is added before or after the list. Null objects or empty strings within the array are represented by empty strings.
StringUtils.join(null, *) = null StringUtils.join([], *) = "" StringUtils.join([null], *) = "" StringUtils.join([1, 2, 3], ';') = "1;2;3" StringUtils.join([1, 2, 3], null) = "123"
array - the array of values to join together, may be null
delimiter - the separator character to use
startIndex - the first index to start joining from. It is an error to pass in a start index past the end of the array
endIndex - the index to stop joining from (exclusive). It is an error to pass in an end index past the end of the array
null if null array input
Joins the elements of the provided array into a single String containing the provided list of elements.
No delimiter is added before or after the list. Null objects or empty strings within the array are represented by empty strings.
StringUtils.join(null, *) = null StringUtils.join([], *) = "" StringUtils.join([null], *) = "" StringUtils.join([1, 2, 3], ';') = "1;2;3" StringUtils.join([1, 2, 3], null) = "123"
array - the array of values to join together, may be null
separator - the separator character to use
null if null array input
Joins the elements of the provided array into a single String containing the provided list of elements.
No delimiter is added before or after the list. Null objects or empty strings within the array are represented by empty strings.
StringUtils.join(null, *) = null StringUtils.join([], *) = "" StringUtils.join([null], *) = "" StringUtils.join([1, 2, 3], ';') = "1;2;3" StringUtils.join([1, 2, 3], null) = "123"
array - the array of values to join together, may be null
delimiter - the separator character to use
startIndex - the first index to start joining from. It is an error to pass in a start index past the end of the array
endIndex - the index to stop joining from (exclusive). It is an error to pass in an end index past the end of the array
null if null array input
Joins the elements of the provided
Iterable
into a single String containing the provided elements.
No delimiter is added before or after the list. Null objects or empty strings within the iteration are represented by empty strings.
See the examples here: join(Object[],char).
iterable - the Iterable providing the values to join together, may be null
separator - the separator character to use
null if null iterator input
Joins the elements of the provided
Iterable
into a single String containing the provided elements.
No delimiter is added before or after the list. A null separator is the same as an empty String ("").
See the examples here: join(Object[],String).
iterable - the Iterable providing the values to join together, may be null
separator - the separator character to use, null treated as ""
null if null iterator input
Joins the elements of the provided
Iterator
into a single String containing the provided elements.
No delimiter is added before or after the list. Null objects or empty strings within the iteration are represented by empty strings.
See the examples here: join(Object[],char).
iterator - the Iterator of values to join together, may be null
separator - the separator character to use
null if null iterator input
Joins the elements of the provided
Iterator
into a single String containing the provided elements.
No delimiter is added before or after the list. A null separator is the same as an empty String ("").
See the examples here: join(Object[],String).
iterator - the Iterator of values to join together, may be null
separator - the separator character to use, null treated as ""
null if null iterator input
Joins the elements of the provided
List
into a single String containing the provided list of elements.
No delimiter is added before or after the list. Null objects or empty strings within the array are represented by empty 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"
list - the List of values to join together, may be null
separator - the separator character to use
startIndex - the first index to start joining from. It is an error to pass in a start index past the end of the list
endIndex - the index to stop joining from (exclusive). It is an error to pass in an end index past the end of the list
null if null list input
Joins the elements of the provided
List
into a single String containing the provided list of elements.
No delimiter is added before or after the list. Null objects or empty strings within the array are represented by empty 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"
list - the List of values to join together, may be null
separator - the separator character to use
startIndex - the first index to start joining from. It is an error to pass in a start index past the end of the list
endIndex - the index to stop joining from (exclusive). It is an error to pass in an end index past the end of the list
null if null list input
Joins the elements of the provided array into a single String containing the provided list of elements.
No delimiter is added before or after the list. Null objects or empty strings within the array are represented by empty strings.
StringUtils.join(null, *) = null StringUtils.join([], *) = "" StringUtils.join([null], *) = "" StringUtils.join([1, 2, 3], ';') = "1;2;3" StringUtils.join([1, 2, 3], null) = "123"
array - the array of values to join together, may be null
separator - the separator character to use
null if null array input
Joins the elements of the provided array into a single String containing the provided list of elements.
No delimiter is added before or after the list. Null objects or empty strings within the array are represented by empty strings.
StringUtils.join(null, *) = null StringUtils.join([], *) = "" StringUtils.join([null], *) = "" StringUtils.join([1, 2, 3], ';') = "1;2;3" StringUtils.join([1, 2, 3], null) = "123"
array - the array of values to join together, may be null
delimiter - the separator character to use
startIndex - the first index to start joining from. It is an error to pass in a start index past the end of the array
endIndex - the index to stop joining from (exclusive). It is an error to pass in an end index past the end of the array
null if null array input
Joins the elements of the provided array into a single String containing the provided list of elements.
No delimiter is added before or after the list. Null objects or empty strings within the array are represented by empty 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"
array - the array of values to join together, may be null
delimiter - the separator character to use
null if null array input
Joins the elements of the provided array into a single String containing the provided list of elements.
No delimiter is added before or after the list. Null objects or empty strings within the array are represented by empty 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"
array - the array of values to join together, may be null
delimiter - the separator character to use
startIndex - the first index to start joining from. It is an error to pass in a start index past the end of the array
endIndex - the index to stop joining from (exclusive). It is an error to pass in an end index past the end of the array
null if null array input
Joins the elements of the provided array into a single String containing the provided list of elements.
No delimiter is added before or after the list. A null separator is the same as an empty String (""). Null objects or empty strings within the array are represented by empty 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"
array - the array of values to join together, may be null
delimiter - the separator character to use, null treated as ""
null if null array input
Joins the elements of the provided array into a single String containing the provided list of elements.
No delimiter is added before or after the list. A null separator is the same as an empty String (""). Null objects or empty strings within the array are represented by empty strings.
StringUtils.join(null, *, *, *) = null StringUtils.join([], *, *, *) = "" StringUtils.join([null], *, *, *) = "" StringUtils.join(["a", "b", "c"], "--", 0, 3) = "a--b--c" StringUtils.join(["a", "b", "c"], "--", 1, 3) = "b--c" StringUtils.join(["a", "b", "c"], "--", 2, 3) = "c" StringUtils.join(["a", "b", "c"], "--", 2, 2) = "" StringUtils.join(["a", "b", "c"], null, 0, 3) = "abc" StringUtils.join(["a", "b", "c"], "", 0, 3) = "abc" StringUtils.join([null, "", "a"], ',', 0, 3) = ",,a"
array - the array of values to join together, may be null
delimiter - the separator character to use, null treated as ""
startIndex - the first index to start joining from.
endIndex - the index to stop joining from (exclusive).
null if null array input; or the empty string if endIndex - startIndex <= 0. The number of joined entries is given by endIndex - startIndex
ArrayIndexOutOfBoundsException - ife
startIndex < 0 or
startIndex >= array.length() or
endIndex < 0 or
endIndex > array.length()
Joins the elements of the provided array into a single String containing the provided list of elements.
No delimiter is added before or after the list. Null objects or empty strings within the array are represented by empty strings.
StringUtils.join(null, *) = null StringUtils.join([], *) = "" StringUtils.join([null], *) = "" StringUtils.join([1, 2, 3], ';') = "1;2;3" StringUtils.join([1, 2, 3], null) = "123"
array - the array of values to join together, may be null
delimiter - the separator character to use
null if null array input
Joins the elements of the provided array into a single String containing the provided list of elements.
No delimiter is added before or after the list. Null objects or empty strings within the array are represented by empty strings.
StringUtils.join(null, *) = null StringUtils.join([], *) = "" StringUtils.join([null], *) = "" StringUtils.join([1, 2, 3], ';') = "1;2;3" StringUtils.join([1, 2, 3], null) = "123"
array - the array of values to join together, may be null
delimiter - the separator character to use
startIndex - the first index to start joining from. It is an error to pass in a start index past the end of the array
endIndex - the index to stop joining from (exclusive). It is an error to pass in an end index past the end of the array
null if null array input
Joins the elements of the provided array into a single String containing the provided list of elements.
No separator is added to the joined String. Null objects or empty strings within the array are represented by empty strings.
StringUtils.join(null) = null StringUtils.join([]) = "" StringUtils.join([null]) = "" StringUtils.join(["a", "b", "c"]) = "abc" StringUtils.join([null, "", "a"]) = "a"
T - the specific type of values to join together
elements - the values to join together, may be null
null if null array input
Joins the elements of the provided varargs into a single String containing the provided elements.
No delimiter is added before or after the list. null elements and separator are treated as empty Strings ("").
StringUtils.joinWith(",", {"a", "b"}) = "a,b"
StringUtils.joinWith(",", {"a", "b",""}) = "a,b,"
StringUtils.joinWith(",", {"a", null, "b"}) = "a,,b"
StringUtils.joinWith(null, {"a", "b"}) = "ab"
delimiter - the separator character to use, null treated as ""
array - the varargs providing the values to join together. null elements are treated as ""
IllegalArgumentException - if a null varargs is provided
Finds the last index within a CharSequence, handling
null
. This method uses
String.lastIndexOf(String)
if possible.
A null CharSequence will return -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
seq - the CharSequence to check, may be null
searchSeq - the CharSequence to find, may be null
null string input
Finds the last index within a CharSequence, handling
null
. This method uses
String.lastIndexOf(String, int)
if possible.
A null CharSequence will return -1. A negative start position returns -1. An empty ("") search CharSequence always matches unless the start position is negative. A start position greater than the string length searches the whole string. The search starts at the startPos and works backwards; matches starting after the start position are ignored.
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
StringUtils.lastIndexOf("aabaabaa", "b", 1) = -1
StringUtils.lastIndexOf("aabaabaa", "b", 2) = 2
StringUtils.lastIndexOf("aabaabaa", "ba", 2) = 2
seq - the CharSequence to check, may be null
searchSeq - the CharSequence to find, may be null
startPos - the start position, negative treated as zero
null string input
Returns the index within
seq
of the last occurrence of the specified character. For values of
searchChar
in the range from 0 to 0xFFFF (inclusive), the index (in Unicode code units) returned is the largest value
ksuch that:
this.charAt(k) == searchChar
is true. For other values of
searchChar
, it is the largest value
ksuch that:
this.codePointAt(k) == searchChar
is true. In either case, if no such character occurs in this string, then
-1
is returned. Furthermore, a
null
or empty ("")
CharSequence
will return
-1
. The
seq CharSequence
object is searched backwards starting at the last character.
StringUtils.lastIndexOf(null, *) = -1
StringUtils.lastIndexOf("", *) = -1
StringUtils.lastIndexOf("aabaabaa", 'a') = 7
StringUtils.lastIndexOf("aabaabaa", 'b') = 5
seq - the CharSequence to check, may be null
searchChar - the character to find
null string input
CharSequenceUtils call to behave more like String
Returns the index within
seq
of the last occurrence of the specified character, searching backward starting at the specified index. For values of
searchChar
in the range from 0 to 0xFFFF (inclusive), the index returned is the largest value
ksuch that:
(this.charAt(k) == searchChar) && (k <= startPos)
is true. For other values of
searchChar
, it is the largest value
ksuch that:
(this.codePointAt(k) == searchChar) && (k <= startPos)
is true. In either case, if no such character occurs in
seq
at or before position
startPos
, then
-1
is returned. Furthermore, a
null
or empty ("")
CharSequence
will return
-1
. A start position greater than the string length searches the whole string. The search starts at the
startPos
and works backwards; matches starting after the start position are ignored.
All indices are specified in char values (Unicode code units).
StringUtils.lastIndexOf(null, *, *) = -1
StringUtils.lastIndexOf("", *, *) = -1
StringUtils.lastIndexOf("aabaabaa", 'b', 8) = 5
StringUtils.lastIndexOf("aabaabaa", 'b', 4) = 2
StringUtils.lastIndexOf("aabaabaa", 'b', 0) = -1
StringUtils.lastIndexOf("aabaabaa", 'b', 9) = 5
StringUtils.lastIndexOf("aabaabaa", 'b', -1) = -1
StringUtils.lastIndexOf("aabaabaa", 'a', 0) = 0
seq - the CharSequence to check, may be null
searchChar - the character to find
startPos - the start position
null string input
Find the latest index of any substring in a set of potential substrings.
A null CharSequence will return -1. A null search array will return -1. A null or zero length search array entry will be ignored, but a search array containing "" will return the length of str if str is not null. This method uses String.indexOf(String) if possible
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
str - the CharSequence to check, may be null
searchStrs - the CharSequences to search for, may be null
Case in-sensitive find of the last index within a CharSequence.
A null CharSequence will return -1. A negative start position returns -1. An empty ("") search CharSequence always matches unless the start position is negative. A start position greater than the string length searches the whole string.
StringUtils.lastIndexOfIgnoreCase(null, *) = -1
StringUtils.lastIndexOfIgnoreCase(*, null) = -1
StringUtils.lastIndexOfIgnoreCase("aabaabaa", "A") = 7
StringUtils.lastIndexOfIgnoreCase("aabaabaa", "B") = 5
StringUtils.lastIndexOfIgnoreCase("aabaabaa", "AB") = 4
str - the CharSequence to check, may be null
searchStr - the CharSequence to find, may be null
null string input
Case in-sensitive find of the last index within a CharSequence from the specified position.
A null CharSequence will return -1. A negative start position returns -1. An empty ("") search CharSequence always matches unless the start position is negative. A start position greater than the string length searches the whole string. The search starts at the startPos and works backwards; matches starting after the start position are ignored.
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
str - the CharSequence to check, may be null
searchStr - the CharSequence to find, may be null
startPos - the start position
null input
Finds the n-th last index within a String, handling
null
. This method uses
String.lastIndexOf(String)
.
A null String will return -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)
str - the CharSequence to check, may be null
searchStr - the CharSequence to find, may be null
ordinal - the n-th last searchStr to find
-1 (INDEX_NOT_FOUND) if no match or null string input
Gets the leftmost
len
characters of a String.
If len characters are not available, or the String is null, the String will be returned without an exception. An empty String is returned if len is negative.
StringUtils.left(null, *) = null
StringUtils.left(*, -ve) = ""
StringUtils.left("", *) = ""
StringUtils.left("abc", 0) = ""
StringUtils.left("abc", 2) = "ab"
StringUtils.left("abc", 4) = "abc"
str - the String to get the leftmost characters from, may be null
len - the length of the required String
null if null String input
Left pad a String with spaces (' ').
The String is padded to the size of 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"
str - the String to pad out, may be null
size - the size to pad to
null if null String input
Left pad a String with a specified character.
Pad to a size of 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"
str - the String to pad out, may be null
size - the size to pad to
padChar - the character to pad with
null if null String input
Left pad a String with a specified String.
Pad to a size of 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"
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
null if null String input
Gets a CharSequence length or 0 if the CharSequence is null.
cs - a CharSequence or null
0 if the CharSequence is null.
Converts a String to lower case as per
String.toLowerCase()
.
A null input String returns null.
StringUtils.lowerCase(null) = null
StringUtils.lowerCase("") = ""
StringUtils.lowerCase("aBc") = "abc"
Note: As described in the documentation for String.toLowerCase(), the result of this method is affected by the current locale. For platform-independent case transformations, the method lowerCase(String, Locale) should be used with a specific locale (e.g. Locale.ENGLISH).
str - the String to lower case, may be null
null if null String input
Converts a String to lower case as per
String.toLowerCase(Locale)
.
A null input String returns null.
StringUtils.lowerCase(null, Locale.ENGLISH) = null
StringUtils.lowerCase("", Locale.ENGLISH) = ""
StringUtils.lowerCase("aBc", Locale.ENGLISH) = "abc"
str - the String to lower case, may be null
locale - the locale that defines the case transformation rules, must not be null
null if null String input
Gets
len
characters from the middle of a String.
If len characters are not available, the remainder of the String will be returned without an exception. If the String is null, null will be returned. An empty String is returned if len is negative or exceeds the length of str.
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"
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
null if null String input
Similar to
https://www.w3.org/TR/xpath/#function-normalize -spaceThe function returns the argument string with whitespace normalized by using {@link #trim(String)} to remove leading and trailing whitespace and then replacing sequences of whitespace characters by a single space.
In XML Whitespace characters are the same as those allowed by the
Sproduction, which is S ::= (#x20 | #x9 | #xD | #xA)+
Java's regexp pattern \s defines whitespace as [ \t\n\x0B\f\r]
For reference:
The difference is that Java's whitespace includes vertical tab and form feed, which this functional will also normalize. Additionally {@link #trim(String)} removes control characters (char <= 32) from both ends of this String.
str - the source String to normalize whitespaces from, may be null
null if null String input
Finds the n-th index within a CharSequence, handling
null
. This method uses
String.indexOf(String)
if possible.
Note: The code starts looking for a match at the start of the target, incrementing the starting index by one after each successful match (unless searchStr is an empty string in which case the position is never incremented and 0 is returned immediately). This means that matches may overlap.
A null CharSequence will return -1.
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
Matches may overlap:
StringUtils.ordinalIndexOf("ababab", "aba", 1) = 0
StringUtils.ordinalIndexOf("ababab", "aba", 2) = 2
StringUtils.ordinalIndexOf("ababab", "aba", 3) = -1
StringUtils.ordinalIndexOf("abababab", "abab", 1) = 0
StringUtils.ordinalIndexOf("abababab", "abab", 2) = 2
StringUtils.ordinalIndexOf("abababab", "abab", 3) = 4
StringUtils.ordinalIndexOf("abababab", "abab", 4) = -1
Note that 'head(CharSequence str, int n)' may be implemented as:
str.substring(0, lastOrdinalIndexOf(str, "\n", n))
str - the CharSequence to check, may be null
searchStr - the CharSequence to find, may be null
ordinal - the n-th searchStr to find
-1 (INDEX_NOT_FOUND) if no match or null string input
Overlays part of a String with another String.
A null string input returns 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"
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
null if null String input
Prepends the prefix to the start of the string if the string does not already start with any of the prefixes.
StringUtils.prependIfMissing(null, null) = null
StringUtils.prependIfMissing("abc", null) = "abc"
StringUtils.prependIfMissing("", "xyz") = "xyz"
StringUtils.prependIfMissing("abc", "xyz") = "xyzabc"
StringUtils.prependIfMissing("xyzabc", "xyz") = "xyzabc"
StringUtils.prependIfMissing("XYZabc", "xyz") = "xyzXYZabc"
With additional prefixes,
StringUtils.prependIfMissing(null, null, null) = null
StringUtils.prependIfMissing("abc", null, null) = "abc"
StringUtils.prependIfMissing("", "xyz", null) = "xyz"
StringUtils.prependIfMissing("abc", "xyz", new CharSequence[]{null}) = "xyzabc"
StringUtils.prependIfMissing("abc", "xyz", "") = "abc"
StringUtils.prependIfMissing("abc", "xyz", "mno") = "xyzabc"
StringUtils.prependIfMissing("xyzabc", "xyz", "mno") = "xyzabc"
StringUtils.prependIfMissing("mnoabc", "xyz", "mno") = "mnoabc"
StringUtils.prependIfMissing("XYZabc", "xyz", "mno") = "xyzXYZabc"
StringUtils.prependIfMissing("MNOabc", "xyz", "mno") = "xyzMNOabc"
str - The string.
prefix - The prefix to prepend to the start of the string.
prefixes - Additional prefixes that are valid.
Prepends the prefix to the start of the string if the string does not already start, case-insensitive, with any of the prefixes.
StringUtils.prependIfMissingIgnoreCase(null, null) = null
StringUtils.prependIfMissingIgnoreCase("abc", null) = "abc"
StringUtils.prependIfMissingIgnoreCase("", "xyz") = "xyz"
StringUtils.prependIfMissingIgnoreCase("abc", "xyz") = "xyzabc"
StringUtils.prependIfMissingIgnoreCase("xyzabc", "xyz") = "xyzabc"
StringUtils.prependIfMissingIgnoreCase("XYZabc", "xyz") = "XYZabc"
With additional prefixes,
StringUtils.prependIfMissingIgnoreCase(null, null, null) = null
StringUtils.prependIfMissingIgnoreCase("abc", null, null) = "abc"
StringUtils.prependIfMissingIgnoreCase("", "xyz", null) = "xyz"
StringUtils.prependIfMissingIgnoreCase("abc", "xyz", new CharSequence[]{null}) = "xyzabc"
StringUtils.prependIfMissingIgnoreCase("abc", "xyz", "") = "abc"
StringUtils.prependIfMissingIgnoreCase("abc", "xyz", "mno") = "xyzabc"
StringUtils.prependIfMissingIgnoreCase("xyzabc", "xyz", "mno") = "xyzabc"
StringUtils.prependIfMissingIgnoreCase("mnoabc", "xyz", "mno") = "mnoabc"
StringUtils.prependIfMissingIgnoreCase("XYZabc", "xyz", "mno") = "XYZabc"
StringUtils.prependIfMissingIgnoreCase("MNOabc", "xyz", "mno") = "MNOabc"
str - The string.
prefix - The prefix to prepend to the start of the string.
prefixes - Additional prefixes that are valid (optional).
Removes all occurrences of a character from within the source string.
A null source string will return null. An empty ("") source string will return the empty string.
StringUtils.remove(null, *) = null
StringUtils.remove("", *) = ""
StringUtils.remove("queued", 'u') = "qeed"
StringUtils.remove("queued", 'z') = "queued"
str - the source String to search, may be null
remove - the char to search for and remove, may be null
null if null String input
Removes all occurrences of a substring from within the source string.
A null source string will return null. An empty ("") source string will return the empty string. A null remove string will return the source string. An empty ("") remove string will return the source string.
StringUtils.remove(null, *) = null
StringUtils.remove("", *) = ""
StringUtils.remove(*, null) = *
StringUtils.remove(*, "") = *
StringUtils.remove("queued", "ue") = "qd"
StringUtils.remove("queued", "zz") = "queued"
str - the source String to search, may be null
remove - the String to search for and remove, may be null
null if null String input
Removes each substring of the text String that matches the given regular expression. This method is a
null
safe equivalent to:
text.replaceAll(regex, StringUtils.EMPTY)Pattern.compile(regex).matcher(text).replaceAll(StringUtils.EMPTY)A null reference passed to this method is a no-op.
Unlike in the removePattern(String, String) method, the Pattern.DOTALL option is NOT automatically added. To use the DOTALL option prepend "(?s)" to the regex. DOTALL is also known as single-line mode in Perl.
StringUtils.removeAll(null, *) = null
StringUtils.removeAll("any", (String) null) = "any"
StringUtils.removeAll("any", "") = "any"
StringUtils.removeAll("any", ".*") = ""
StringUtils.removeAll("any", ".+") = ""
StringUtils.removeAll("abc", ".?") = ""
StringUtils.removeAll("A<__>\n<__>B", "<.*>") = "A\nB"
StringUtils.removeAll("A<__>\n<__>B", "(?s)<.*>") = "AB"
StringUtils.removeAll("ABCabc123abc", "[a-z]") = "ABC123"
text - text to remove from, may be null
regex - the regular expression to which this string is to be matched
null if null String input
PatternSyntaxException - if the regular expression's syntax is invalid
Removes a substring only if it is at the end of a source string, otherwise returns the source string.
A null source string will return null. An empty ("") source string will return the empty string. A null search string will return the source string.
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"
str - the source String to search, may be null
remove - the String to search for and remove, may be null
null if null String input
Case-insensitive removal of a substring if it is at the end of a source string, otherwise returns the source string.
A null source string will return null. An empty ("") source string will return the empty string. A null search string will return the source string.
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")
str - the source String to search, may be null
remove - the String to search for (case-insensitive) and remove, may be null
null if null String input
Removes the first substring of the text string that matches the given regular expression. This method is a
null
safe equivalent to:
text.replaceFirst(regex, StringUtils.EMPTY)Pattern.compile(regex).matcher(text).replaceFirst(StringUtils.EMPTY)A null reference passed to this method is a no-op.
The Pattern.DOTALL option is NOT automatically added. To use the DOTALL option prepend "(?s)" to the regex. DOTALL is also known as single-line mode in Perl.
StringUtils.removeFirst(null, *) = null
StringUtils.removeFirst("any", (String) null) = "any"
StringUtils.removeFirst("any", "") = "any"
StringUtils.removeFirst("any", ".*") = ""
StringUtils.removeFirst("any", ".+") = ""
StringUtils.removeFirst("abc", ".?") = "bc"
StringUtils.removeFirst("A<__>\n<__>B", "<.*>") = "A\n<__>B"
StringUtils.removeFirst("A<__>\n<__>B", "(?s)<.*>") = "AB"
StringUtils.removeFirst("ABCabc123", "[a-z]") = "ABCbc123"
StringUtils.removeFirst("ABCabc123abc", "[a-z]+") = "ABC123abc"
text - text to remove from, may be null
regex - the regular expression to which this string is to be matched
null if null String input
PatternSyntaxException - if the regular expression's syntax is invalid
Case-insensitive removal of all occurrences of a substring from within the source string.
A null source string will return null. An empty ("") source string will return the empty string. A null remove string will return the source string. An empty ("") remove string will return the source string.
StringUtils.removeIgnoreCase(null, *) = null
StringUtils.removeIgnoreCase("", *) = ""
StringUtils.removeIgnoreCase(*, null) = *
StringUtils.removeIgnoreCase(*, "") = *
StringUtils.removeIgnoreCase("queued", "ue") = "qd"
StringUtils.removeIgnoreCase("queued", "zz") = "queued"
StringUtils.removeIgnoreCase("quEUed", "UE") = "qd"
StringUtils.removeIgnoreCase("queued", "zZ") = "queued"
str - the source String to search, may be null
remove - the String to search for (case-insensitive) and remove, may be null
null if null String input
Removes each substring of the source String that matches the given regular expression using the DOTALL option. This call is a
null
safe equivalent to:
source.replaceAll("(?s)" + regex, StringUtils.EMPTY)Pattern.compile(regex, Pattern.DOTALL).matcher(source).replaceAll(StringUtils.EMPTY)A null reference passed to this method is a no-op.
StringUtils.removePattern(null, *) = null
StringUtils.removePattern("any", (String) null) = "any"
StringUtils.removePattern("A<__>\n<__>B", "<.*>") = "AB"
StringUtils.removePattern("ABCabc123", "[a-z]") = "ABC123"
source - the source string
regex - the regular expression to which this string is to be matched
String
null reference passed to this method is a no-op.
Removes a char only if it is at the beginning of a source string, otherwise returns the source string.
A null source string will return null. An empty ("") source string will return the empty string. A null search char will return the source string.
StringUtils.removeStart(null, *) = null
StringUtils.removeStart("", *) = ""
StringUtils.removeStart(*, null) = *
StringUtils.removeStart("/path", '/') = "path"
StringUtils.removeStart("path", '/') = "path"
StringUtils.removeStart("path", 0) = "path"
str - the source String to search, may be null.
remove - the char to search for and remove.
null if null String input.
Removes a substring only if it is at the beginning of a source string, otherwise returns the source string.
A null source string will return null. An empty ("") source string will return the empty string. A null search string will return the source string.
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"
str - the source String to search, may be null
remove - the String to search for and remove, may be null
null if null String input
Case-insensitive removal of a substring if it is at the beginning of a source string, otherwise returns the source string.
A null source string will return null. An empty ("") source string will return the empty string. A null search string will return the source string.
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"
str - the source String to search, may be null
remove - the String to search for (case-insensitive) and remove, may be null
null if null String input
Returns padding using the specified delimiter repeated to a given length.
StringUtils.repeat('e', 0) = ""
StringUtils.repeat('e', 3) = "eee"
StringUtils.repeat('e', -2) = ""
Note: this method does not support padding with Unicode Supplementary Characters as they require a pair of chars to be represented. If you are needing to support full I18N of your applications consider using repeat(String, int) instead.
repeat - character to repeat
count - number of times to repeat char, negative treated as zero
Repeats a String
repeat
times to form a new 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) = ""
repeat - the String to repeat, may be null
count - number of times to repeat str, negative treated as zero
null if null String input
Repeats a String
repeat
times to form a new 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) = "xx"
StringUtils.repeat("?", ", ", 3) = "?, ?, ?"
repeat - the String to repeat, may be null
separator - the String to inject, may be null
count - number of times to repeat str, negative treated as zero
null if null String input
Replaces all occurrences of a String within another String.
A 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"
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
null if null String input
Replaces a String with another String inside a larger String, for the first
max
values of the search String.
A null reference passed to this method is a no-op.
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"
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 -1 if no maximum
null if null String input
Replaces each substring of the text String that matches the given regular expression with the given replacement. This method is a
null
safe equivalent to:
text.replaceAll(regex, replacement)Pattern.compile(regex).matcher(text).replaceAll(replacement)A null reference passed to this method is a no-op.
Unlike in the replacePattern(String, String, String) method, the Pattern.DOTALL option is NOT automatically added. To use the DOTALL option prepend "(?s)" to the regex. DOTALL is also known as single-line mode in Perl.
StringUtils.replaceAll(null, *, *) = null
StringUtils.replaceAll("any", (String) null, *) = "any"
StringUtils.replaceAll("any", *, null) = "any"
StringUtils.replaceAll("", "", "zzz") = "zzz"
StringUtils.replaceAll("", ".*", "zzz") = "zzz"
StringUtils.replaceAll("", ".+", "zzz") = ""
StringUtils.replaceAll("abc", "", "ZZ") = "ZZaZZbZZcZZ"
StringUtils.replaceAll("<__>\n<__>", "<.*>", "z") = "z\nz"
StringUtils.replaceAll("<__>\n<__>", "(?s)<.*>", "z") = "z"
StringUtils.replaceAll("ABCabc123", "[a-z]", "_") = "ABC___123"
StringUtils.replaceAll("ABCabc123", "[^A-Z0-9]+", "_") = "ABC_123"
StringUtils.replaceAll("ABCabc123", "[^A-Z0-9]+", "") = "ABC123"
StringUtils.replaceAll("Lorem ipsum dolor sit", "( +)([a-z]+)", "_$2") = "Lorem_ipsum_dolor_sit"
text - text to search and replace in, may be null
regex - the regular expression to which this string is to be matched
replacement - the string to be substituted for each match
null if null String input
PatternSyntaxException - if the regular expression's syntax is invalid
Replaces all occurrences of a character in a String with another. This is a null-safe version of
String.replace(char, char)
.
A null string input returns null. An empty ("") string input returns an empty string.
StringUtils.replaceChars(null, *, *) = null
StringUtils.replaceChars("", *, *) = ""
StringUtils.replaceChars("abcba", 'b', 'y') = "aycya"
StringUtils.replaceChars("abcba", 'z', 'y') = "abcba"
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
null if null string input
Replaces multiple characters in a String in one go. This method can also be used to delete characters.
For example:replaceChars("hello", "ho", "jy") = jelly.
A null string input returns null. An empty ("") string input returns an empty string. A null or empty set of search characters returns the input string.
The length of the search characters should normally equal the length of the replace characters. If the search characters is longer, then the extra search characters are deleted. If the search characters is shorter, then the extra replace characters are ignored.
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"
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
null if null string input
Replaces all occurrences of Strings within another String.
A null reference passed to this method is a no-op, or if any "search string" or "string to replace" is null, that replace will be ignored. This will not repeat. For repeating replaces, call the overloaded method.
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"
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
null if null String input
IllegalArgumentException - if the lengths of the arrays are not the same (null is ok, and/or size 0)
Replaces all occurrences of Strings within another String.
A null reference passed to this method is a no-op, or if any "search string" or "string to replace" is null, that replace will be ignored.
StringUtils.replaceEachRepeatedly(null, *, *) = null
StringUtils.replaceEachRepeatedly("", *, *) = ""
StringUtils.replaceEachRepeatedly("aba", null, null) = "aba"
StringUtils.replaceEachRepeatedly("aba", new String[0], null) = "aba"
StringUtils.replaceEachRepeatedly("aba", null, new String[0]) = "aba"
StringUtils.replaceEachRepeatedly("aba", new String[]{"a"}, null) = "aba"
StringUtils.replaceEachRepeatedly("aba", new String[]{"a"}, new String[]{""}) = "b"
StringUtils.replaceEachRepeatedly("aba", new String[]{null}, new String[]{"a"}) = "aba"
StringUtils.replaceEachRepeatedly("abcde", new String[]{"ab", "d"}, new String[]{"w", "t"}) = "wcte"
(example of how it repeats)
StringUtils.replaceEachRepeatedly("abcde", new String[]{"ab", "d"}, new String[]{"d", "t"}) = "tcte"
StringUtils.replaceEachRepeatedly("abcde", new String[]{"ab", "d"}, new String[]{"d", "ab"}) = IllegalStateException
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
null if null String input
IllegalStateException - if the search is repeating and there is an endless loop due to outputs of one being inputs to another
IllegalArgumentException - if the lengths of the arrays are not the same (null is ok, and/or size 0)
Replaces the first substring of the text string that matches the given regular expression with the given replacement. This method is a
null
safe equivalent to:
text.replaceFirst(regex, replacement)Pattern.compile(regex).matcher(text).replaceFirst(replacement)A null reference passed to this method is a no-op.
The Pattern.DOTALL option is NOT automatically added. To use the DOTALL option prepend "(?s)" to the regex. DOTALL is also known as single-line mode in Perl.
StringUtils.replaceFirst(null, *, *) = null
StringUtils.replaceFirst("any", (String) null, *) = "any"
StringUtils.replaceFirst("any", *, null) = "any"
StringUtils.replaceFirst("", "", "zzz") = "zzz"
StringUtils.replaceFirst("", ".*", "zzz") = "zzz"
StringUtils.replaceFirst("", ".+", "zzz") = ""
StringUtils.replaceFirst("abc", "", "ZZ") = "ZZabc"
StringUtils.replaceFirst("<__>\n<__>", "<.*>", "z") = "z\n<__>"
StringUtils.replaceFirst("<__>\n<__>", "(?s)<.*>", "z") = "z"
StringUtils.replaceFirst("ABCabc123", "[a-z]", "_") = "ABC_bc123"
StringUtils.replaceFirst("ABCabc123abc", "[^A-Z0-9]+", "_") = "ABC_123abc"
StringUtils.replaceFirst("ABCabc123abc", "[^A-Z0-9]+", "") = "ABC123abc"
StringUtils.replaceFirst("Lorem ipsum dolor sit", "( +)([a-z]+)", "_$2") = "Lorem_ipsum dolor sit"
text - text to search and replace in, may be null
regex - the regular expression to which this string is to be matched
replacement - the string to be substituted for the first match
null if null String input
PatternSyntaxException - if the regular expression's syntax is invalid
Case insensitively replaces all occurrences of a String within another String.
A null reference passed to this method is a no-op.
StringUtils.replaceIgnoreCase(null, *, *) = null
StringUtils.replaceIgnoreCase("", *, *) = ""
StringUtils.replaceIgnoreCase("any", null, *) = "any"
StringUtils.replaceIgnoreCase("any", *, null) = "any"
StringUtils.replaceIgnoreCase("any", "", *) = "any"
StringUtils.replaceIgnoreCase("aba", "a", null) = "aba"
StringUtils.replaceIgnoreCase("abA", "A", "") = "b"
StringUtils.replaceIgnoreCase("aba", "A", "z") = "zbz"
text - text to search and replace in, may be null
searchString - the String to search for (case-insensitive), may be null
replacement - the String to replace it with, may be null
null if null String input
Case insensitively replaces a String with another String inside a larger String, for the first
max
values of the search String.
A null reference passed to this method is a no-op.
StringUtils.replaceIgnoreCase(null, *, *, *) = null
StringUtils.replaceIgnoreCase("", *, *, *) = ""
StringUtils.replaceIgnoreCase("any", null, *, *) = "any"
StringUtils.replaceIgnoreCase("any", *, null, *) = "any"
StringUtils.replaceIgnoreCase("any", "", *, *) = "any"
StringUtils.replaceIgnoreCase("any", *, *, 0) = "any"
StringUtils.replaceIgnoreCase("abaa", "a", null, -1) = "abaa"
StringUtils.replaceIgnoreCase("abaa", "a", "", -1) = "b"
StringUtils.replaceIgnoreCase("abaa", "a", "z", 0) = "abaa"
StringUtils.replaceIgnoreCase("abaa", "A", "z", 1) = "zbaa"
StringUtils.replaceIgnoreCase("abAa", "a", "z", 2) = "zbza"
StringUtils.replaceIgnoreCase("abAa", "a", "z", -1) = "zbzz"
text - text to search and replace in, may be null
searchString - the String to search for (case-insensitive), may be null
replacement - the String to replace it with, may be null
max - maximum number of values to replace, or -1 if no maximum
null if null String input
Replaces a String with another String inside a larger String, once.
A 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"
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
null if null String input
Case insensitively replaces a String with another String inside a larger String, once.
A null reference passed to this method is a no-op.
StringUtils.replaceOnceIgnoreCase(null, *, *) = null
StringUtils.replaceOnceIgnoreCase("", *, *) = ""
StringUtils.replaceOnceIgnoreCase("any", null, *) = "any"
StringUtils.replaceOnceIgnoreCase("any", *, null) = "any"
StringUtils.replaceOnceIgnoreCase("any", "", *) = "any"
StringUtils.replaceOnceIgnoreCase("aba", "a", null) = "aba"
StringUtils.replaceOnceIgnoreCase("aba", "a", "") = "ba"
StringUtils.replaceOnceIgnoreCase("aba", "a", "z") = "zba"
StringUtils.replaceOnceIgnoreCase("FoOFoofoo", "foo", "") = "Foofoo"
text - text to search and replace in, may be null
searchString - the String to search for (case-insensitive), may be null
replacement - the String to replace with, may be null
null if null String input
Replaces each substring of the source String that matches the given regular expression with the given replacement using the
Pattern.DOTALL
option. DOTALL is also known as single-line mode in Perl. This call is a
null
safe equivalent to:
source.replaceAll("(?s)" + regex, replacement)Pattern.compile(regex, Pattern.DOTALL).matcher(source).replaceAll(replacement)A null reference passed to this method is a no-op.
StringUtils.replacePattern(null, *, *) = null
StringUtils.replacePattern("any", (String) null, *) = "any"
StringUtils.replacePattern("any", *, null) = "any"
StringUtils.replacePattern("", "", "zzz") = "zzz"
StringUtils.replacePattern("", ".*", "zzz") = "zzz"
StringUtils.replacePattern("", ".+", "zzz") = ""
StringUtils.replacePattern("<__>\n<__>", "<.*>", "z") = "z"
StringUtils.replacePattern("ABCabc123", "[a-z]", "_") = "ABC___123"
StringUtils.replacePattern("ABCabc123", "[^A-Z0-9]+", "_") = "ABC_123"
StringUtils.replacePattern("ABCabc123", "[^A-Z0-9]+", "") = "ABC123"
StringUtils.replacePattern("Lorem ipsum dolor sit", "( +)([a-z]+)", "_$2") = "Lorem_ipsum_dolor_sit"
source - the source string
regex - the regular expression to which this string is to be matched
replacement - the string to be substituted for each match
String
null reference passed to this method is a no-op.
Reverses a String as per
StringBuilder.reverse()
.
A null String returns null.
StringUtils.reverse(null) = null
StringUtils.reverse("") = ""
StringUtils.reverse("bat") = "tab"
str - the String to reverse, may be null
null if null String input
Reverses a String that is delimited by a specific character.
The Strings between the delimiters are not reversed. Thus java.lang.String becomes String.lang.java (if the delimiter is '.').
StringUtils.reverseDelimited(null, *) = null
StringUtils.reverseDelimited("", *) = ""
StringUtils.reverseDelimited("a.b.c", 'x') = "a.b.c"
StringUtils.reverseDelimited("a.b.c", ".") = "c.b.a"
str - the String to reverse, may be null
separatorChar - the separator character to use
null if null String input
Gets the rightmost
len
characters of a String.
If len characters are not available, or the String is null, the String will be returned without an an exception. An empty String is returned if len is negative.
StringUtils.right(null, *) = null
StringUtils.right(*, -ve) = ""
StringUtils.right("", *) = ""
StringUtils.right("abc", 0) = ""
StringUtils.right("abc", 2) = "bc"
StringUtils.right("abc", 4) = "abc"
str - the String to get the rightmost characters from, may be null
len - the length of the required String
null if null String input
Right pad a String with spaces (' ').
The String is padded to the size of 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"
str - the String to pad out, may be null
size - the size to pad to
null if null String input
Right pad a String with a specified character.
The String is padded to the size of 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"
str - the String to pad out, may be null
size - the size to pad to
padChar - the character to pad with
null if null String input
Right pad a String with a specified String.
The String is padded to the size of 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 "
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
null if null String input
Rotate (circular shift) a String of
shift
characters.
shift > 0, right circular shift (ex : ABCDEF => FABCDE)shift < 0, left circular shift (ex : ABCDEF => BCDEFA) StringUtils.rotate(null, *) = null
StringUtils.rotate("", *) = ""
StringUtils.rotate("abcdefg", 0) = "abcdefg"
StringUtils.rotate("abcdefg", 2) = "fgabcde"
StringUtils.rotate("abcdefg", -2) = "cdefgab"
StringUtils.rotate("abcdefg", 7) = "abcdefg"
StringUtils.rotate("abcdefg", -7) = "abcdefg"
StringUtils.rotate("abcdefg", 9) = "fgabcde"
StringUtils.rotate("abcdefg", -9) = "cdefgab"
str - the String to rotate, may be null
shift - number of time to shift (positive : right shift, negative : left shift)
shift == 0, or null if null String input
Splits the provided text into an array, using whitespace as the separator. Whitespace is defined by
Character.isWhitespace(char)
.
The separator is not included in the returned String array. Adjacent separators are treated as one separator. For more control over the split use the StrTokenizer class.
A null input String returns null.
StringUtils.split(null) = null
StringUtils.split("") = []
StringUtils.split("abc def") = ["abc", "def"]
StringUtils.split("abc def") = ["abc", "def"]
StringUtils.split(" abc ") = ["abc"]
str - the String to parse, may be null
null if null String input
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 null input String returns 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"]
str - the String to parse, may be null
separatorChar - the character used as the delimiter
null if null String input
Splits the provided text into an array, separators specified. This is an alternative to using StringTokenizer.
The separator is not included in the returned String array. Adjacent separators are treated as one separator. For more control over the split use the StrTokenizer class.
A null input String returns null. A null separatorChars splits on whitespace.
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"]
str - the String to parse, may be null
separatorChars - the characters used as the delimiters, null splits on whitespace
null if null String input
Splits the provided text into an array with a maximum length, separators specified.
The separator is not included in the returned String array. Adjacent separators are treated as one separator.
A null input String returns null. A null separatorChars splits on whitespace.
If more than max delimited substrings are found, the last returned string includes all characters after the first max - 1 returned strings (including separator characters).
StringUtils.split(null, *, *) = null
StringUtils.split("", *, *) = []
StringUtils.split("ab cd ef", null, 0) = ["ab", "cd", "ef"]
StringUtils.split("ab cd ef", null, 0) = ["ab", "cd", "ef"]
StringUtils.split("ab:cd:ef", ":", 0) = ["ab", "cd", "ef"]
StringUtils.split("ab:cd:ef", ":", 2) = ["ab", "cd:ef"]
str - the String to parse, may be null
separatorChars - the characters used as the delimiters, null splits on whitespace
max - the maximum number of elements to include in the array. A zero or negative value implies no limit
null if null String input
Splits a String by Character type as returned by
java.lang.Character.getType(char)
. Groups of contiguous characters of the same type are returned as complete tokens.
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"]
str - the String to split, may be null
null if null String input
Splits a String by Character type as returned by java.lang.Character.getType(char). Groups of contiguous characters of the same type are returned as complete tokens, with the following exception: the character of type Character.UPPERCASE_LETTER, if any, immediately preceding a token of type Character.LOWERCASE_LETTER will belong to the following token rather than to the preceding, if any, Character.UPPERCASE_LETTER token.
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"]
str - the String to split, may be null
null if null String input
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 null input String returns null. A 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"]
str - the String to parse, may be null
separator - String containing the String to be used as a delimiter, null splits on whitespace
null if null String was input
Splits the provided text into an array, separator string specified. Returns a maximum of
max
substrings.
The separator(s) will not be included in the returned String array. Adjacent separators are treated as one separator.
A null input String returns null. A null separator splits on whitespace.
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"]
str - the String to parse, may be null
separator - String containing the String to be used as a delimiter, null splits on whitespace
max - the maximum number of elements to include in the returned array. A zero or negative value implies no limit.
null if null String was input
Splits the provided text into an array, separator string specified.
The separator is not included in the returned String array. Adjacent separators are treated as separators for empty tokens. For more control over the split use the StrTokenizer class.
A null input String returns null. A null separator splits on whitespace.
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"]
str - the String to parse, may be null
separator - String containing the String to be used as a delimiter, null splits on whitespace
null if null String was input
Splits the provided text into an array, separator string specified. Returns a maximum of
max
substrings.
The separator is not included in the returned String array. Adjacent separators are treated as separators for empty tokens. For more control over the split use the StrTokenizer class.
A null input String returns null. A null separator splits on whitespace.
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"]
str - the String to parse, may be null
separator - String containing the String to be used as a delimiter, null splits on whitespace
max - the maximum number of elements to include in the returned array. A zero or negative value implies no limit.
null if null String was input
Splits the provided text into an array, using whitespace as the separator, preserving all tokens, including empty tokens created by adjacent separators. This is an alternative to using StringTokenizer. Whitespace is defined by
Character.isWhitespace(char)
.
The separator is not included in the returned String array. Adjacent separators are treated as separators for empty tokens. For more control over the split use the StrTokenizer class.
A null input String returns null.
StringUtils.splitPreserveAllTokens(null) = null
StringUtils.splitPreserveAllTokens("") = []
StringUtils.splitPreserveAllTokens("abc def") = ["abc", "def"]
StringUtils.splitPreserveAllTokens("abc def") = ["abc", "", "def"]
StringUtils.splitPreserveAllTokens(" abc ") = ["", "abc", ""]
str - the String to parse, may be null
null if null String input
Splits the provided text into an array, separator specified, preserving all tokens, including empty tokens created by adjacent separators. This is an alternative to using StringTokenizer.
The separator is not included in the returned String array. Adjacent separators are treated as separators for empty tokens. For more control over the split use the StrTokenizer class.
A null input String returns null.
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", ""]
str - the String to parse, may be null
separatorChar - the character used as the delimiter, null splits on whitespace
null if null String input
Splits the provided text into an array, separators specified, preserving all tokens, including empty tokens created by adjacent separators. This is an alternative to using StringTokenizer.
The separator is not included in the returned String array. Adjacent separators are treated as separators for empty tokens. For more control over the split use the StrTokenizer class.
A null input String returns null. A null separatorChars splits on whitespace.
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", ""]
str - the String to parse, may be null
separatorChars - the characters used as the delimiters, null splits on whitespace
null if null String input
Splits the provided text into an array with a maximum length, separators specified, preserving all tokens, including empty tokens created by adjacent separators.
The separator is not included in the returned String array. Adjacent separators are treated as separators for empty tokens. Adjacent separators are treated as one separator.
A null input String returns null. A null separatorChars splits on whitespace.
If more than max delimited substrings are found, the last returned string includes all characters after the first max - 1 returned strings (including separator characters).
StringUtils.splitPreserveAllTokens(null, *, *) = null
StringUtils.splitPreserveAllTokens("", *, *) = []
StringUtils.splitPreserveAllTokens("ab de fg", null, 0) = ["ab", "de", "fg"]
StringUtils.splitPreserveAllTokens("ab de fg", null, 0) = ["ab", "", "", "de", "fg"]
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"]
str - the String to parse, may be null
separatorChars - the characters used as the delimiters, null splits on whitespace
max - the maximum number of elements to include in the array. A zero or negative value implies no limit
null if null String input
Tests if a CharSequence starts with a specified prefix.
nulls are handled without exceptions. Two 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
str - the CharSequence to check, may be null
prefix - the prefix to find, may be null
true if the CharSequence starts with the prefix, case-sensitive, or both null
Tests if a CharSequence starts with any of the provided case-sensitive prefixes.
StringUtils.startsWithAny(null, null) = false
StringUtils.startsWithAny(null, new String[] {"abc"}) = false
StringUtils.startsWithAny("abcxyz", null) = false
StringUtils.startsWithAny("abcxyz", new String[] {""}) = true
StringUtils.startsWithAny("abcxyz", new String[] {"abc"}) = true
StringUtils.startsWithAny("abcxyz", new String[] {null, "xyz", "abc"}) = true
StringUtils.startsWithAny("abcxyz", null, "xyz", "ABCX") = false
StringUtils.startsWithAny("ABCXYZ", null, "xyz", "abc") = false
sequence - the CharSequence to check, may be null
searchStrings - the case-sensitive CharSequence prefixes, may be empty or contain null
true if the input sequence is null AND no searchStrings are provided, or the input sequence begins with any of the provided case-sensitive searchStrings.
Case-insensitive check if a CharSequence starts with a specified prefix.
nulls are handled without exceptions. Two 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
str - the CharSequence to check, may be null
prefix - the prefix to find, may be null
true if the CharSequence starts with the prefix, case-insensitive, or both null
Strips whitespace from the start and end of a String.
This is similar to trim(String) but removes whitespace. Whitespace is defined by Character.isWhitespace(char).
A null input String returns null.
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"
str - the String to remove whitespace from, may be null
null if null String input
Strips any of a set of characters from the start and end of a String. This is similar to
String.trim()
but allows the characters to be stripped to be controlled.
A null input String returns null. An empty string ("") input returns the empty string.
If the stripChars String is null, whitespace is stripped as defined by Character.isWhitespace(char). Alternatively use strip(String).
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"
str - the String to remove characters from, may be null
stripChars - the characters to remove, null treated as whitespace
null if null String input
Removes diacritics (~= accents) from a string. The case will not be altered.
For instance, 'à' will be replaced by 'a'.
Decomposes ligatures and digraphs per the KD column in the Unicode Normalization Chart.
StringUtils.stripAccents(null) = null
StringUtils.stripAccents("") = ""
StringUtils.stripAccents("control") = "control"
StringUtils.stripAccents("éclair") = "eclair"
StringUtils.stripAccents("ᵃᵇᶜ¹²³") = "abc123"
StringUtils.stripAccents("¼ ½ ¾") = "1⁄4 1⁄2 3⁄4"
See also Unicode Standard Annex #15 Unicode Normalization Forms.
input - String to be stripped
Strips whitespace from the start and end of every String in an array. Whitespace is defined by
Character.isWhitespace(char)
.
A new array is returned each time, except for length zero. A null array will return null. An empty array will return itself. A null array entry will be ignored.
StringUtils.stripAll(null) = null StringUtils.stripAll([]) = [] StringUtils.stripAll(["abc", " abc"]) = ["abc", "abc"] StringUtils.stripAll(["abc ", null]) = ["abc", null]
strs - the array to remove whitespace from, may be null
null if null array input
Strips any of a set of characters from the start and end of every String in an array.
Whitespace is defined by Character.isWhitespace(char).
A new array is returned each time, except for length zero. A null array will return null. An empty array will return itself. A null array entry will be ignored. A null stripChars will strip whitespace as defined by Character.isWhitespace(char).
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]
strs - the array to remove characters from, may be null
stripChars - the characters to remove, null treated as whitespace
null if null array input
Strips any of a set of characters from the end of a String.
A null input String returns null. An empty string ("") input returns the empty string.
If the stripChars String is null, whitespace is stripped as defined by Character.isWhitespace(char).
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"
str - the String to remove characters from, may be null
stripChars - the set of characters to remove, null treated as whitespace
null if null String input
Strips any of a set of characters from the start of a String.
A null input String returns null. An empty string ("") input returns the empty string.
If the stripChars String is null, whitespace is stripped as defined by Character.isWhitespace(char).
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 "
str - the String to remove characters from, may be null
stripChars - the characters to remove, null treated as whitespace
null if null String input
Strips whitespace from the start and end of a String returning an empty String if
null
input.
This is similar to trimToEmpty(String) but removes whitespace. Whitespace is defined by Character.isWhitespace(char).
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"
str - the String to be stripped, may be null
null input
Strips whitespace from the start and end of a String returning
null
if the String is empty ("") after the strip.
This is similar to trimToNull(String) but removes whitespace. Whitespace is defined by Character.isWhitespace(char).
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"
str - the String to be stripped, may be null
null if whitespace, empty or null String input
Gets a substring from the specified String avoiding exceptions.
A negative start position can be used to start n characters from the end of the String.
A null String will return null. An empty ("") String will return "".
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"
str - the String to get the substring from, may be null
start - the position to start from, negative means count back from the end of the String by this many characters
null if null String input
Gets a substring from the specified String avoiding exceptions.
A negative start position can be used to start/end n characters from the end of the String.
The returned substring starts with the character in the start position and ends before the end position. All position counting is zero-based -- i.e., to start at the beginning of the string use start = 0. Negative start and end positions can be used to specify offsets relative to the end of the String.
If start is not strictly to the left of end, "" is returned.
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"
str - the String to get the substring from, may be null
start - the position to start from, negative means count back from the end of the String by this many characters
end - the position to end at (exclusive), negative means count back from the end of the String by this many characters
null if null String input
Gets the substring after the first occurrence of a separator. The separator is not returned.
A null string input will return null. An empty ("") string input will return the empty string.
If nothing is found, the empty string is returned.
StringUtils.substringAfter(null, *) = null
StringUtils.substringAfter("", *) = ""
StringUtils.substringAfter("abc", 'a') = "bc"
StringUtils.substringAfter("abcba", 'b') = "cba"
StringUtils.substringAfter("abc", 'c') = ""
StringUtils.substringAfter("abc", 'd') = ""
StringUtils.substringAfter(" abc", 32) = "abc"
str - the String to get a substring from, may be null
separator - the character (Unicode code point) to search.
null if null String input
Gets the substring after the first occurrence of a separator. The separator is not returned.
A null string input will return null. An empty ("") string input will return the empty string. A null separator will return the empty string if the input string is not null.
If nothing is found, the empty string is returned.
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"
str - the String to get a substring from, may be null
separator - the String to search for, may be null
null if null String input
Gets the substring after the last occurrence of a separator. The separator is not returned.
A null string input will return null. An empty ("") string input will return the empty string.
If nothing is found, the empty string is returned.
StringUtils.substringAfterLast(null, *) = null
StringUtils.substringAfterLast("", *) = ""
StringUtils.substringAfterLast("abc", 'a') = "bc"
StringUtils.substringAfterLast(" bc", 32) = "bc"
StringUtils.substringAfterLast("abcba", 'b') = "a"
StringUtils.substringAfterLast("abc", 'c') = ""
StringUtils.substringAfterLast("a", 'a') = ""
StringUtils.substringAfterLast("a", 'z') = ""
str - the String to get a substring from, may be null
separator - the character (Unicode code point) to search.
null if null String input
Gets the substring after the last occurrence of a separator. The separator is not returned.
A null string input will return null. An empty ("") string input will return the empty string. An empty or null separator will return the empty string if the input string is not 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") = ""
str - the String to get a substring from, may be null
separator - the String to search for, may be null
null if null String input
Gets the substring before the first occurrence of a separator. The separator is not returned.
A null string input will return null. An empty ("") string input will return the empty string.
If nothing is found, the string input is returned.
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"
str - the String to get a substring from, may be null
separator - the character (Unicode code point) to search.
null if null String input
Gets the substring before the first occurrence of a separator. The separator is not returned.
A null string input will return null. An empty ("") string input will return the empty string. A null separator will return the input string.
If nothing is found, the string input is returned.
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"
str - the String to get a substring from, may be null
separator - the String to search for, may be null
null if null String input
Gets the substring before the last occurrence of a separator. The separator is not returned.
A null string input will return null. An empty ("") string input will return the empty string. An empty or 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"
str - the String to get a substring from, may be null
separator - the String to search for, may be null
null if null String input
Gets the String that is nested in between two instances of the same String.
A null input String returns null. A null tag returns null.
StringUtils.substringBetween(null, *) = null
StringUtils.substringBetween("", "") = ""
StringUtils.substringBetween("", "tag") = null
StringUtils.substringBetween("tagabctag", null) = null
StringUtils.substringBetween("tagabctag", "") = ""
StringUtils.substringBetween("tagabctag", "tag") = "abc"
str - the String containing the substring, may be null
tag - the String before and after the substring, may be null
null if no match
Gets the String that is nested in between two Strings. Only the first match is returned.
A null input String returns null. A null open/close returns null (no match). An empty ("") open and close returns an empty string.
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"
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
null if no match
Searches a String for substrings delimited by a start and end tag, returning all matching substrings in an array.
A null input String returns null. A null open/close returns null (no match). An empty ("") open/close returns null (no match).
StringUtils.substringsBetween("[a][b][c]", "[", "]") = ["a","b","c"]
StringUtils.substringsBetween(null, *, *) = null
StringUtils.substringsBetween(*, null, *) = null
StringUtils.substringsBetween(*, *, null) = null
StringUtils.substringsBetween("", "[", "]") = []
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
null if no match
Swaps the case of a String changing upper and title case to lower case, and lower case to upper case.
For a word based algorithm, see WordUtils.swapCase(String). A null input String returns 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.
str - the String to swap case, may be null
null if null String input
Converts a
CharSequence
into an array of code points.
Valid pairs of surrogate code units will be converted into a single supplementary code point. Isolated surrogate code units (i.e. a high surrogate not followed by a low surrogate or a low surrogate not preceded by a high surrogate) will be returned as-is.
StringUtils.toCodePoints(null) = null
StringUtils.toCodePoints("") = [] // empty array
cs - the character sequence to convert
Converts a byte[] to a String using the specified character encoding.
bytes - the byte array to read from
charset - the encoding to use, if null then use the platform default
NullPointerException - if bytes is null
UnsupportedEncodingException.
Converts the given source String as a lower-case using the
Locale.ROOT
locale in a null-safe manner.
source - A source String or null.
Locale.ROOT locale or null.
Converts the given source String as an upper-case using the
Locale.ROOT
locale in a null-safe manner.
source - A source String or null.
Locale.ROOT locale or null.
Converts a byte[] to a String using the specified character encoding.
bytes - the byte array to read from
charsetName - the encoding to use, if null then use the platform default
NullPointerException - if the input is null
Removes control characters (char <= 32) from both ends of this String, handling
null
by returning
null
.
The String is trimmed using String.trim(). Trim removes start and end characters <= 32. To strip whitespace use strip(String).
To trim your choice of characters, use the strip(String, String) methods.
StringUtils.trim(null) = null
StringUtils.trim("") = ""
StringUtils.trim(" ") = ""
StringUtils.trim("abc") = "abc"
StringUtils.trim(" abc ") = "abc"
str - the String to be trimmed, may be null
null if null String input
Removes control characters (char <= 32) from both ends of this String returning an empty String ("") if the String is empty ("") after the trim or if it is
null
.
The String is trimmed using String.trim(). Trim removes start and end characters <= 32. To strip whitespace use stripToEmpty(String).
StringUtils.trimToEmpty(null) = ""
StringUtils.trimToEmpty("") = ""
StringUtils.trimToEmpty(" ") = ""
StringUtils.trimToEmpty("abc") = "abc"
StringUtils.trimToEmpty(" abc ") = "abc"
str - the String to be trimmed, may be null
null input
Removes control characters (char <= 32) from both ends of this String returning
null
if the String is empty ("") after the trim or if it is
null
.
The String is trimmed using String.trim(). Trim removes start and end characters <= 32. To strip whitespace use stripToNull(String).
StringUtils.trimToNull(null) = null
StringUtils.trimToNull("") = null
StringUtils.trimToNull(" ") = null
StringUtils.trimToNull("abc") = "abc"
StringUtils.trimToNull(" abc ") = "abc"
str - the String to be trimmed, may be null
null if only chars <= 32, empty or null String input
Truncates a String. This will turn "Now is the time for all good men" into "Now is the time for".
Specifically:
str is less than maxWidth characters long, return it.substring(str, 0, maxWidth).maxWidth is less than 0, throw an IllegalArgumentException.maxWidth. StringUtils.truncate(null, 0) = null
StringUtils.truncate(null, 2) = null
StringUtils.truncate("", 4) = ""
StringUtils.truncate("abcdefg", 4) = "abcd"
StringUtils.truncate("abcdefg", 6) = "abcdef"
StringUtils.truncate("abcdefg", 7) = "abcdefg"
StringUtils.truncate("abcdefg", 8) = "abcdefg"
StringUtils.truncate("abcdefg", -1) = throws an IllegalArgumentException
str - the String to truncate, may be null
maxWidth - maximum length of result String, must be positive
null if null String input
IllegalArgumentException - If maxWidth is less than 0
Truncates a String. This will turn "Now is the time for all good men" into "is the time for all".
Works like truncate(String, int), but allows you to specify a "left edge" offset.
Specifically:
str is less than maxWidth characters long, return it.substring(str, offset, maxWidth).maxWidth is less than 0, throw an IllegalArgumentException.offset is less than 0, throw an IllegalArgumentException.maxWidth. StringUtils.truncate(null, 0, 0) = null
StringUtils.truncate(null, 2, 4) = null
StringUtils.truncate("", 0, 10) = ""
StringUtils.truncate("", 2, 10) = ""
StringUtils.truncate("abcdefghij", 0, 3) = "abc"
StringUtils.truncate("abcdefghij", 5, 6) = "fghij"
StringUtils.truncate("raspberry peach", 10, 15) = "peach"
StringUtils.truncate("abcdefghijklmno", 0, 10) = "abcdefghij"
StringUtils.truncate("abcdefghijklmno", -1, 10) = throws an IllegalArgumentException
StringUtils.truncate("abcdefghijklmno", Integer.MIN_VALUE, 10) = throws an IllegalArgumentException
StringUtils.truncate("abcdefghijklmno", Integer.MIN_VALUE, Integer.MAX_VALUE) = throws an IllegalArgumentException
StringUtils.truncate("abcdefghijklmno", 0, Integer.MAX_VALUE) = "abcdefghijklmno"
StringUtils.truncate("abcdefghijklmno", 1, 10) = "bcdefghijk"
StringUtils.truncate("abcdefghijklmno", 2, 10) = "cdefghijkl"
StringUtils.truncate("abcdefghijklmno", 3, 10) = "defghijklm"
StringUtils.truncate("abcdefghijklmno", 4, 10) = "efghijklmn"
StringUtils.truncate("abcdefghijklmno", 5, 10) = "fghijklmno"
StringUtils.truncate("abcdefghijklmno", 5, 5) = "fghij"
StringUtils.truncate("abcdefghijklmno", 5, 3) = "fgh"
StringUtils.truncate("abcdefghijklmno", 10, 3) = "klm"
StringUtils.truncate("abcdefghijklmno", 10, Integer.MAX_VALUE) = "klmno"
StringUtils.truncate("abcdefghijklmno", 13, 1) = "n"
StringUtils.truncate("abcdefghijklmno", 13, Integer.MAX_VALUE) = "no"
StringUtils.truncate("abcdefghijklmno", 14, 1) = "o"
StringUtils.truncate("abcdefghijklmno", 14, Integer.MAX_VALUE) = "o"
StringUtils.truncate("abcdefghijklmno", 15, 1) = ""
StringUtils.truncate("abcdefghijklmno", 15, Integer.MAX_VALUE) = ""
StringUtils.truncate("abcdefghijklmno", Integer.MAX_VALUE, Integer.MAX_VALUE) = ""
StringUtils.truncate("abcdefghij", 3, -1) = throws an IllegalArgumentException
StringUtils.truncate("abcdefghij", -2, 4) = throws an IllegalArgumentException
str - the String to truncate, may be null
offset - left edge of source String
maxWidth - maximum length of result String, must be positive
null if null String input
IllegalArgumentException - If offset or maxWidth is less than 0
Uncapitalizes a String, changing the first character to lower case as per
Character.toLowerCase(int)
. No other characters are changed.
For a word based algorithm, see WordUtils.uncapitalize(String). A null input String returns null.
StringUtils.uncapitalize(null) = null
StringUtils.uncapitalize("") = ""
StringUtils.uncapitalize("cat") = "cat"
StringUtils.uncapitalize("Cat") = "cat"
StringUtils.uncapitalize("CAT") = "cAT"
str - the String to uncapitalize, may be null
null if null String input
Unwraps a given string from a character.
StringUtils.unwrap(null, null) = null
StringUtils.unwrap(null, '\0') = null
StringUtils.unwrap(null, '1') = null
StringUtils.unwrap("a", 'a') = "a"
StringUtils.unwrap("aa", 'a') = ""
StringUtils.unwrap("\'abc\'", '\'') = "abc"
StringUtils.unwrap("AABabcBAA", 'A') = "ABabcBA"
StringUtils.unwrap("A", '#') = "A"
StringUtils.unwrap("#A", '#') = "#A"
StringUtils.unwrap("A#", '#') = "A#"
str - the String to be unwrapped, can be null
wrapChar - the character used to unwrap
Unwraps a given string from another string.
StringUtils.unwrap(null, null) = null
StringUtils.unwrap(null, "") = null
StringUtils.unwrap(null, "1") = null
StringUtils.unwrap("a", "a") = "a"
StringUtils.unwrap("aa", "a") = ""
StringUtils.unwrap("\'abc\'", "\'") = "abc"
StringUtils.unwrap("\"abc\"", "\"") = "abc"
StringUtils.unwrap("AABabcBAA", "AA") = "BabcB"
StringUtils.unwrap("A", "#") = "A"
StringUtils.unwrap("#A", "#") = "#A"
StringUtils.unwrap("A#", "#") = "A#"
str - the String to be unwrapped, can be null
wrapToken - the String used to unwrap
Converts a String to upper case as per
String.toUpperCase()
.
A null input String returns null.
StringUtils.upperCase(null) = null
StringUtils.upperCase("") = ""
StringUtils.upperCase("aBc") = "ABC"
Note: As described in the documentation for String.toUpperCase(), the result of this method is affected by the current locale. For platform-independent case transformations, the method upperCase(String, Locale) should be used with a specific locale (e.g. Locale.ENGLISH).
str - the String to upper case, may be null
null if null String input
Converts a String to upper case as per
String.toUpperCase(Locale)
.
A null input String returns null.
StringUtils.upperCase(null, Locale.ENGLISH) = null
StringUtils.upperCase("", Locale.ENGLISH) = ""
StringUtils.upperCase("aBc", Locale.ENGLISH) = "ABC"
str - the String to upper case, may be null
locale - the locale that defines the case transformation rules, must not be null
null if null String input
Returns the string representation of the char array or null.
value - the character array.
Wraps a string with a char.
StringUtils.wrap(null, *) = null
StringUtils.wrap("", *) = ""
StringUtils.wrap("ab", '\0') = "ab"
StringUtils.wrap("ab", 'x') = "xabx"
StringUtils.wrap("ab", '\'') = "'ab'"
StringUtils.wrap("\"ab\"", '\"') = "\"\"ab\"\""
str - the string to be wrapped, may be null
wrapWith - the char that will wrap str
null if str == null
Wraps a String with another String.
A null input String returns null.
StringUtils.wrap(null, *) = null
StringUtils.wrap("", *) = ""
StringUtils.wrap("ab", null) = "ab"
StringUtils.wrap("ab", "x") = "xabx"
StringUtils.wrap("ab", "\"") = "\"ab\""
StringUtils.wrap("\"ab\"", "\"") = "\"\"ab\"\""
StringUtils.wrap("ab", "'") = "'ab'"
StringUtils.wrap("'abcd'", "'") = "''abcd''"
StringUtils.wrap("\"abcd\"", "'") = "'\"abcd\"'"
StringUtils.wrap("'abcd'", "\"") = "\"'abcd'\""
str - the String to be wrapper, may be null
wrapWith - the String that will wrap str
null if null String input
Wraps a string with a char if that char is missing from the start or end of the given string.
A new String will not be created if str is already wrapped.
StringUtils.wrapIfMissing(null, *) = null
StringUtils.wrapIfMissing("", *) = ""
StringUtils.wrapIfMissing("ab", '\0') = "ab"
StringUtils.wrapIfMissing("ab", 'x') = "xabx"
StringUtils.wrapIfMissing("ab", '\'') = "'ab'"
StringUtils.wrapIfMissing("\"ab\"", '\"') = "\"ab\""
StringUtils.wrapIfMissing("/", '/') = "/"
StringUtils.wrapIfMissing("a/b/c", '/') = "/a/b/c/"
StringUtils.wrapIfMissing("/a/b/c", '/') = "/a/b/c/"
StringUtils.wrapIfMissing("a/b/c/", '/') = "/a/b/c/"
str - the string to be wrapped, may be null
wrapWith - the char that will wrap str
null if str == null
Wraps a string with a string if that string is missing from the start or end of the given string.
A new String will not be created if str is already wrapped.
StringUtils.wrapIfMissing(null, *) = null
StringUtils.wrapIfMissing("", *) = ""
StringUtils.wrapIfMissing("ab", null) = "ab"
StringUtils.wrapIfMissing("ab", "x") = "xabx"
StringUtils.wrapIfMissing("ab", "\"") = "\"ab\""
StringUtils.wrapIfMissing("\"ab\"", "\"") = "\"ab\""
StringUtils.wrapIfMissing("ab", "'") = "'ab'"
StringUtils.wrapIfMissing("'abcd'", "'") = "'abcd'"
StringUtils.wrapIfMissing("\"abcd\"", "'") = "'\"abcd\"'"
StringUtils.wrapIfMissing("'abcd'", "\"") = "\"'abcd'\""
StringUtils.wrapIfMissing("/", "/") = "/"
StringUtils.wrapIfMissing("a/b/c", "/") = "/a/b/c/"
StringUtils.wrapIfMissing("/a/b/c", "/") = "/a/b/c/"
StringUtils.wrapIfMissing("a/b/c/", "/") = "/a/b/c/"
str - the string to be wrapped, may be null
wrapWith - the string that will wrap str
null if str == null
RetroSearch is an open source project built by @garambo | Open a GitHub Issue
Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo
HTML:
3.2
| Encoding:
UTF-8
| Version:
0.7.4