StringUtils (Lang 2.3 API)

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

PREV CLASS NEXT CLASS

FRAMES NO FRAMES

SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

org.apache.commons.lang
Class StringUtils

java.lang.Object
  org.apache.commons.lang.StringUtils

public class StringUtils
extends Object
extends Object

Operations on String that are null safe.

IsEmpty/IsBlank - checks if a String contains text
Trim/Strip - removes leading and trailing whitespace
Equals - compares two strings null-safe
IndexOf/LastIndexOf/Contains - null-safe index-of checks
IndexOfAny/LastIndexOfAny/IndexOfAnyBut/LastIndexOfAnyBut - index-of any of a set of Strings
ContainsOnly/ContainsNone - does String contains only/none of these characters
Substring/Left/Right/Mid - null-safe substring extractions
SubstringBefore/SubstringAfter/SubstringBetween - substring extraction relative to other strings
Split/Join - splits a String into an array of substrings and vice versa
Remove/Delete - removes part of a String
Replace/Overlay - Searches a String and replaces one String with another
Chomp/Chop - removes the last part of a String
LeftPad/RightPad/Center/Repeat - pads a String
UpperCase/LowerCase/SwapCase/Capitalize/Uncapitalize - changes the case of a String
CountMatches - counts the number of occurrences of one String in another
IsAlpha/IsNumeric/IsWhitespace/IsAsciiPrintable - checks the characters in a String
DefaultString - protects against a null input String
Reverse/ReverseDelimited - reverses a String
Abbreviate - abbreviates a string using ellipsis
Difference - compares two Strings and reports on their differences
LevensteinDistance - the number of changes needed to change one String into another

The StringUtils class defines certain words related to String handling.

null - null
empty - a zero-length string ("")
space - the space character (' ', char 32)
whitespace - the characters defined by Character.isWhitespace(char)
trim - the characters <= 32 as in 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 (except for deprecated methods).

Methods in this class give sample code to explain their operation. The symbol * is used to indicate any input including null.

Since:: 1.0
Version:: $Id: StringUtils.java 492377 2007-01-04 01:20:30Z scolebourne $
Author:: Apache Jakarta Turbine, Jon S. Stevens, Daniel Rall, Greg Coladonato, Ed Korthof, Rand McNeely, Stephen Colebourne, Fredrik Westermarck, Holger Krauth, Alexander Day Chaffee, Henning P. Schmiedehausen, Arun Mammen Thomas, Gary Gregory, Phil Steitz, Al Chou, Michael Davey, Reuben Sivan, Chris Hyzer
See Also:: String

Field Summary
`static String`	`EMPTY` The empty String `""`.
`static int`	`INDEX_NOT_FOUND` Represents a failed index search.

Constructor Summary
`StringUtils()` `StringUtils` instances should NOT be constructed in standard programming.

Method Summary
`static String`	`abbreviate(String str, int maxWidth)` Abbreviates a String using ellipses.
`static String`	`abbreviate(String str, int offset, int maxWidth)` Abbreviates a String using ellipses.
`static String`	`capitalise(String str)` Deprecated. Use the standardly named `capitalize(String)`. Method will be removed in Commons Lang 3.0.
`static String`	`capitaliseAllWords(String str)` Deprecated. Use the relocated `WordUtils.capitalize(String)`. Method will be removed in Commons Lang 3.0.
`static String`	`capitalize(String str)` Capitalizes a String changing the first letter to title case as per `Character.toTitleCase(char)`.
`static String`	`center(String str, int size)` Centers a String in a larger String of size `size` using the space character (' ').
`static String`	`center(String str, int size, char padChar)` Centers a String in a larger String of size `size`.
`static String`	`center(String str, int size, String padStr)` Centers a String in a larger String of size `size`.
`static String`	`chomp(String str)` Removes one newline from end of a String if it's there, otherwise leave it alone.
`static String`	`chomp(String str, String separator)` Removes `separator` from the end of `str` if it's there, otherwise leave it alone.
`static String`	`chompLast(String str)` Deprecated. Use `chomp(String)` instead. Method will be removed in Commons Lang 3.0.
`static String`	`chompLast(String str, String sep)` Deprecated. Use `chomp(String,String)` instead. Method will be removed in Commons Lang 3.0.
`static String`	`chop(String str)` Remove the last character from a String.
`static String`	`chopNewline(String str)` Deprecated. Use `chomp(String)` instead. Method will be removed in Commons Lang 3.0.
`static String`	`clean(String str)` Deprecated. Use the clearer named `trimToEmpty(String)`. Method will be removed in Commons Lang 3.0.
`static String`	`concatenate(Object[] array)` Deprecated. Use the better named `join(Object[])` instead. Method will be removed in Commons Lang 3.0.
`static boolean`	`contains(String str, char searchChar)` Checks if String contains a search character, handling `null`.
`static boolean`	`contains(String str, String searchStr)` Checks if String contains a search String, handling `null`.
`static boolean`	`containsIgnoreCase(String str, String searchStr)` Checks if String contains a search String irrespective of case, handling `null`.
`static boolean`	`containsNone(String str, char[] invalidChars)` Checks that the String does not contain certain characters.
`static boolean`	`containsNone(String str, String invalidChars)` Checks that the String does not contain certain characters.
`static boolean`	`containsOnly(String str, char[] valid)` Checks if the String contains only certain characters.
`static boolean`	`containsOnly(String str, String validChars)` Checks if the String contains only certain characters.
`static int`	`countMatches(String str, String sub)` Counts how many times the substring appears in the larger String.
`static String`	`defaultIfEmpty(String str, String defaultStr)` Returns either the passed in String, or if the String is empty or `null`, the value of `defaultStr`.
`static String`	`defaultString(String str)` Returns either the passed in String, or if the String is `null`, an empty String ("").
`static String`	`defaultString(String str, String defaultStr)` Returns either the passed in String, or if the String is `null`, the value of `defaultStr`.
`static String`	`deleteSpaces(String str)` Deprecated. Use the better localized `deleteWhitespace(String)`. Method will be removed in Commons Lang 3.0.
`static String`	`deleteWhitespace(String str)` Deletes all whitespaces from a String as defined by `Character.isWhitespace(char)`.
`static String`	`difference(String str1, String str2)` Compares two Strings, and returns the portion where they differ.
`static boolean`	`equals(String str1, String str2)` Compares two Strings, returning `true` if they are equal.
`static boolean`	`equalsIgnoreCase(String str1, String str2)` Compares two Strings, returning `true` if they are equal ignoring the case.
`static String`	`escape(String str)` Deprecated. Use `StringEscapeUtils.escapeJava(String)` This method will be removed in Commons Lang 3.0
`static String`	`getChomp(String str, String sep)` Deprecated. Use `substringAfterLast(String, String)` instead (although this doesn't include the separator) Method will be removed in Commons Lang 3.0.
`static int`	`getLevenshteinDistance(String s, String t)` Find the Levenshtein distance between two Strings.
`static String`	`getNestedString(String str, String tag)` Deprecated. Use the better named `substringBetween(String, String)`. Method will be removed in Commons Lang 3.0.
`static String`	`getNestedString(String str, String open, String close)` Deprecated. Use the better named `substringBetween(String, String, String)`. Method will be removed in Commons Lang 3.0.
`static String`	`getPrechomp(String str, String sep)` Deprecated. Use `substringBefore(String,String)` instead (although this doesn't include the separator). Method will be removed in Commons Lang 3.0.
`static int`	`indexOf(String str, char searchChar)` Finds the first index within a String, handling `null`.
`static int`	`indexOf(String str, char searchChar, int startPos)` Finds the first index within a String from a start position, handling `null`.
`static int`	`indexOf(String str, String searchStr)` Finds the first index within a String, handling `null`.
`static int`	`indexOf(String str, String searchStr, int startPos)` Finds the first index within a String, handling `null`.
`static int`	`indexOfAny(String str, char[] searchChars)` Search a String to find the first index of any character in the given set of characters.
`static int`	`indexOfAny(String str, String searchChars)` Search a String to find the first index of any character in the given set of characters.
`static int`	`indexOfAny(String str, String[] searchStrs)` Find the first index of any of a set of potential substrings.
`static int`	`indexOfAnyBut(String str, char[] searchChars)` Search a String to find the first index of any character not in the given set of characters.
`static int`	`indexOfAnyBut(String str, String searchChars)` Search a String to find the first index of any character not in the given set of characters.
`static int`	`indexOfDifference(String str1, String str2)` Compares two Strings, and returns the index at which the Strings begin to differ.
`static boolean`	`isAlpha(String str)` Checks if the String contains only unicode letters.
`static boolean`	`isAlphanumeric(String str)` Checks if the String contains only unicode letters or digits.
`static boolean`	`isAlphanumericSpace(String str)` Checks if the String contains only unicode letters, digits or space (`' '`).
`static boolean`	`isAlphaSpace(String str)` Checks if the String contains only unicode letters and space (' ').
`static boolean`	`isAsciiPrintable(String str)` Checks if the string contains only ASCII printable characters.
`static boolean`	`isBlank(String str)` Checks if a String is whitespace, empty ("") or null.
`static boolean`	`isEmpty(String str)` Checks if a String is empty ("") or null.
`static boolean`	`isNotBlank(String str)` Checks if a String is not empty (""), not null and not whitespace only.
`static boolean`	`isNotEmpty(String str)` Checks if a String is not empty ("") and not null.
`static boolean`	`isNumeric(String str)` Checks if the String contains only unicode digits.
`static boolean`	`isNumericSpace(String str)` Checks if the String contains only unicode digits or space (`' '`).
`static boolean`	`isWhitespace(String str)` Checks if the String contains only whitespace.
`static String`	`join(Collection collection, char separator)` Joins the elements of the provided `Collection` into a single String containing the provided elements.
`static String`	`join(Collection collection, String separator)` Joins the elements of the provided `Collection` into a single String containing the provided elements.
`static String`	`join(Iterator iterator, char separator)` Joins the elements of the provided `Iterator` into a single String containing the provided elements.
`static String`	`join(Iterator iterator, String separator)` Joins the elements of the provided `Iterator` into a single String containing the provided elements.
`static String`	`join(Object[] array)` Joins the elements of the provided array into a single String containing the provided list of elements.
`static String`	`join(Object[] array, char separator)` Joins the elements of the provided array into a single String containing the provided list of elements.
`static String`	`join(Object[] array, char separator, int startIndex, int endIndex)` Joins the elements of the provided array into a single String containing the provided list of elements.
`static String`	`join(Object[] array, String separator)` Joins the elements of the provided array into a single String containing the provided list of elements.
`static String`	`join(Object[] array, String separator, int startIndex, int endIndex)` Joins the elements of the provided array into a single String containing the provided list of elements.
`static int`	`lastIndexOf(String str, char searchChar)` Finds the last index within a String, handling `null`.
`static int`	`lastIndexOf(String str, char searchChar, int startPos)` Finds the last index within a String from a start position, handling `null`.
`static int`	`lastIndexOf(String str, String searchStr)` Finds the last index within a String, handling `null`.
`static int`	`lastIndexOf(String str, String searchStr, int startPos)` Finds the first index within a String, handling `null`.
`static int`	`lastIndexOfAny(String str, String[] searchStrs)` Find the latest index of any of a set of potential substrings.
`static String`	`left(String str, int len)` Gets the leftmost `len` characters of a String.
`static String`	`leftPad(String str, int size)` Left pad a String with spaces (' ').
`static String`	`leftPad(String str, int size, char padChar)` Left pad a String with a specified character.
`static String`	`leftPad(String str, int size, String padStr)` Left pad a String with a specified String.
`static String`	`lowerCase(String str)` Converts a String to lower case as per `String.toLowerCase()`.
`static String`	`mid(String str, int pos, int len)` Gets `len` characters from the middle of a String.
`static int`	`ordinalIndexOf(String str, String searchStr, int ordinal)` Finds the n-th index within a String, handling `null`.
`static String`	`overlay(String str, String overlay, int start, int end)` Overlays part of a String with another String.
`static String`	`overlayString(String text, String overlay, int start, int end)` Deprecated. Use better named `overlay(String, String, int, int)` instead. Method will be removed in Commons Lang 3.0.
`static String`	`prechomp(String str, String sep)` Deprecated. Use `substringAfter(String,String)` instead. Method will be removed in Commons Lang 3.0.
`static String`	`remove(String str, char remove)` Removes all occurances of a character from within the source string.
`static String`	`remove(String str, String remove)` Removes all occurances of a substring from within the source string.
`static String`	`removeEnd(String str, String remove)` Removes a substring only if it is at the end of a source string, otherwise returns the source string.
`static String`	`removeStart(String str, String remove)` Removes a substring only if it is at the begining of a source string, otherwise returns the source string.
`static String`	`repeat(String str, int repeat)` Repeat a String `repeat` times to form a new String.
`static String`	`replace(String text, String repl, String with)` Replaces all occurrences of a String within another String.
`static String`	`replace(String text, String repl, String with, int max)` Replaces a String with another String inside a larger String, for the first `max` values of the search String.
`static String`	`replaceChars(String str, char searchChar, char replaceChar)` Replaces all occurrences of a character in a String with another.
`static String`	`replaceChars(String str, String searchChars, String replaceChars)` Replaces multiple characters in a String in one go.
`static String`	`replaceOnce(String text, String repl, String with)` Replaces a String with another String inside a larger String, once.
`static String`	`reverse(String str)` Reverses a String as per `StringBuffer.reverse()`.
`static String`	`reverseDelimited(String str, char separatorChar)` Reverses a String that is delimited by a specific character.
`static String`	`reverseDelimitedString(String str, String separatorChars)` Deprecated. Use `reverseDelimited(String, char)` instead. This method is broken as the join doesn't know which char to use. Method will be removed in Commons Lang 3.0.
`static String`	`right(String str, int len)` Gets the rightmost `len` characters of a String.
`static String`	`rightPad(String str, int size)` Right pad a String with spaces (' ').
`static String`	`rightPad(String str, int size, char padChar)` Right pad a String with a specified character.
`static String`	`rightPad(String str, int size, String padStr)` Right pad a String with a specified String.
`static String[]`	`split(String str)` Splits the provided text into an array, using whitespace as the separator.
`static String[]`	`split(String str, char separatorChar)` Splits the provided text into an array, separator specified.
`static String[]`	`split(String str, String separatorChars)` Splits the provided text into an array, separators specified.
`static String[]`	`split(String str, String separatorChars, int max)` Splits the provided text into an array with a maximum length, separators specified.
`static String[]`	`splitByWholeSeparator(String str, String separator)` Splits the provided text into an array, separator string specified.
`static String[]`	`splitByWholeSeparator(String str, String separator, int max)` Splits the provided text into an array, separator string specified.
`static String[]`	`splitPreserveAllTokens(String str)` Splits the provided text into an array, using whitespace as the separator, preserving all tokens, including empty tokens created by adjacent separators.
`static String[]`	`splitPreserveAllTokens(String str, char separatorChar)` Splits the provided text into an array, separator specified, preserving all tokens, including empty tokens created by adjacent separators.
`static String[]`	`splitPreserveAllTokens(String str, String separatorChars)` Splits the provided text into an array, separators specified, preserving all tokens, including empty tokens created by adjacent separators.
`static String[]`	`splitPreserveAllTokens(String str, String separatorChars, int max)` Splits the provided text into an array with a maximum length, separators specified, preserving all tokens, including empty tokens created by adjacent separators.
`static String`	`strip(String str)` Strips whitespace from the start and end of a String.
`static String`	`strip(String str, String stripChars)` Strips any of a set of characters from the start and end of a String.
`static String[]`	`stripAll(String[] strs)` Strips whitespace from the start and end of every String in an array.
`static String[]`	`stripAll(String[] strs, String stripChars)` Strips any of a set of characters from the start and end of every String in an array.
`static String`	`stripEnd(String str, String stripChars)` Strips any of a set of characters from the end of a String.
`static String`	`stripStart(String str, String stripChars)` Strips any of a set of characters from the start of a String.
`static String`	`stripToEmpty(String str)` Strips whitespace from the start and end of a String returning an empty String if `null` input.
`static String`	`stripToNull(String str)` Strips whitespace from the start and end of a String returning `null` if the String is empty ("") after the strip.
`static String`	`substring(String str, int start)` Gets a substring from the specified String avoiding exceptions.
`static String`	`substring(String str, int start, int end)` Gets a substring from the specified String avoiding exceptions.
`static String`	`substringAfter(String str, String separator)` Gets the substring after the first occurrence of a separator.
`static String`	`substringAfterLast(String str, String separator)` Gets the substring after the last occurrence of a separator.
`static String`	`substringBefore(String str, String separator)` Gets the substring before the first occurrence of a separator.
`static String`	`substringBeforeLast(String str, String separator)` Gets the substring before the last occurrence of a separator.
`static String`	`substringBetween(String str, String tag)` Gets the String that is nested in between two instances of the same String.
`static String`	`substringBetween(String str, String open, String close)` Gets the String that is nested in between two Strings.
`static String[]`	`substringsBetween(String str, String open, String close)` Searches a String for substrings delimited by a start and end tag, returning all matching substrings in an array.
`static String`	`swapCase(String str)` Swaps the case of a String changing upper and title case to lower case, and lower case to upper case.
`static String`	`trim(String str)` Removes control characters (char <= 32) from both ends of this String, handling `null` by returning `null`.
`static String`	`trimToEmpty(String str)` 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`.
`static String`	`trimToNull(String str)` 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`.
`static String`	`uncapitalise(String str)` Deprecated. Use the standardly named `uncapitalize(String)`. Method will be removed in Commons Lang 3.0.
`static String`	`uncapitalize(String str)` Uncapitalizes a String changing the first letter to title case as per `Character.toLowerCase(char)`.
`static String`	`upperCase(String str)` Converts a String to upper case as per `String.toUpperCase()`.

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

Field Detail

EMPTY

public static final String EMPTY

The empty String "".

Since:: 2.0
See Also:: Constant Field Values

INDEX_NOT_FOUND

public static final int INDEX_NOT_FOUND

Represents a failed index search.

Since:: 2.1
See Also:: Constant Field Values

Constructor Detail

StringUtils

public StringUtils()

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.

Method Detail

isEmpty

public static boolean isEmpty(String str)

Checks if a String 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 String. That functionality is available in isBlank().

Parameters:: str - the String to check, may be null
Returns:: true if the String is empty or null

isNotEmpty

public static boolean isNotEmpty(String str)

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

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

Parameters:: str - the String to check, may be null
Returns:: true if the String is not empty and not null

isBlank

public static boolean isBlank(String str)

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

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

Parameters:: str - the String to check, may be null
Returns:: true if the String is null, empty or whitespace
Since:: 2.0

isNotBlank

public static boolean isNotBlank(String str)

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

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

Parameters:: str - the String to check, may be null
Returns:: true if the String is not empty and not null and not whitespace
Since:: 2.0

clean

public static String clean(String str)

Deprecated. Use the clearer named trimToEmpty(String). Method will be removed in Commons Lang 3.0.

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

 StringUtils.clean(null)          = ""
 StringUtils.clean("")            = ""
 StringUtils.clean("abc")         = "abc"
 StringUtils.clean("    abc    ") = "abc"
 StringUtils.clean("     ")       = ""

Parameters:: str - the String to clean, may be null
Returns:: the trimmed text, never null
See Also:: String.trim()

trim

public static String trim(String str)

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"

Parameters:: str - the String to be trimmed, may be null
Returns:: the trimmed string, null if null String input

trimToNull

public static String trimToNull(String str)

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"

Parameters:: str - the String to be trimmed, may be null
Returns:: the trimmed String, null if only chars <= 32, empty or null String input
Since:: 2.0

trimToEmpty

public static String trimToEmpty(String str)

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"

Parameters:: str - the String to be trimmed, may be null
Returns:: the trimmed String, or an empty String if null input
Since:: 2.0

strip

public static String strip(String str)

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"

Parameters:: str - the String to remove whitespace from, may be null
Returns:: the stripped String, null if null String input

stripToNull

public static String stripToNull(String str)

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"

Parameters:: str - the String to be stripped, may be null
Returns:: the stripped String, null if whitespace, empty or null String input
Since:: 2.0

stripToEmpty

public static String stripToEmpty(String str)

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"

Parameters:: str - the String to be stripped, may be null
Returns:: the trimmed String, or an empty String if null input
Since:: 2.0

strip

public static String strip(String str,
                           String stripChars)

Strips any of a set of characters from the start and end of a String. This is similar to 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"

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

stripStart

public static String stripStart(String str,
                                String stripChars)

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  "

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

stripEnd

public static String stripEnd(String str,
                              String stripChars)

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"

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

stripAll

public static String[] stripAll(String[] strs)

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]

Parameters:: strs - the array to remove whitespace from, may be null
Returns:: the stripped Strings, null if null array input

stripAll

public static String[] stripAll(String[] strs,
                                String stripChars)

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]

Parameters:: strs - the array to remove characters from, may be null; stripChars - the characters to remove, null treated as whitespace
Returns:: the stripped Strings, null if null array input

equals

public static boolean equals(String str1,
                             String str2)

Compares two Strings, returning true if they are equal.

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

Parameters:: str1 - the first String, may be null; str2 - the second String, may be null
Returns:: true if the Strings are equal, case sensitive, or both null
See Also:: String.equals(Object)

equalsIgnoreCase

public static boolean equalsIgnoreCase(String str1,
                                       String str2)

Compares two Strings, returning true if they are equal ignoring the case.

nulls are handled without exceptions. Two null references are considered equal. Comparison is case insensitive.

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

Parameters:: str1 - the first String, may be null; str2 - the second String, may be null
Returns:: true if the Strings are equal, case insensitive, or both null
See Also:: String.equalsIgnoreCase(String)

indexOf

public static int indexOf(String str,
                          char searchChar)

Finds the first index within a String, handling null. This method uses String.indexOf(int).

A null or empty ("") String will return -1.

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

Parameters:: str - the String to check, may be null; searchChar - the character to find
Returns:: the first index of the search character, -1 if no match or null string input
Since:: 2.0

indexOf

public static int indexOf(String str,
                          char searchChar,
                          int startPos)

Finds the first index within a String from a start position, handling null. This method uses String.indexOf(int, int).

A null or empty ("") String will return -1. A negative start position is treated as zero. A start position greater than the string length returns -1.

 StringUtils.indexOf(null, *, *)          = -1
 StringUtils.indexOf("", *, *)            = -1
 StringUtils.indexOf("aabaabaa", 'b', 0)  = 2
 StringUtils.indexOf("aabaabaa", 'b', 3)  = 5
 StringUtils.indexOf("aabaabaa", 'b', 9)  = -1
 StringUtils.indexOf("aabaabaa", 'b', -1) = 2

Parameters:: str - the String to check, may be null; searchChar - the character to find; startPos - the start position, negative treated as zero
Returns:: the first index of the search character, -1 if no match or null string input
Since:: 2.0

indexOf

public static int indexOf(String str,
                          String searchStr)

Finds the first index within a String, handling null. This method uses String.indexOf(String).

A null String will return -1.

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

Parameters:: str - the String to check, may be null; searchStr - the String to find, may be null
Returns:: the first index of the search String, -1 if no match or null string input
Since:: 2.0

ordinalIndexOf

public static int ordinalIndexOf(String str,
                                 String searchStr,
                                 int ordinal)

Finds the n-th index within a String, handling null. This method uses String.indexOf(String).

A null String 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

Parameters:: str - the String to check, may be null; searchStr - the String to find, may be null; ordinal - the n-th searchStr to find
Returns:: the n-th index of the search String, -1 (INDEX_NOT_FOUND) if no match or null string input
Since:: 2.1

indexOf

public static int indexOf(String str,
                          String searchStr,
                          int startPos)

Finds the first index within a String, handling null. This method uses String.indexOf(String, int).

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

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

Parameters:: str - the String to check, may be null; searchStr - the String to find, may be null; startPos - the start position, negative treated as zero
Returns:: the first index of the search String, -1 if no match or null string input
Since:: 2.0

lastIndexOf

public static int lastIndexOf(String str,
                              char searchChar)

Finds the last index within a String, handling null. This method uses String.lastIndexOf(int).

A null or empty ("") String will return -1.

 StringUtils.lastIndexOf(null, *)         = -1
 StringUtils.lastIndexOf("", *)           = -1
 StringUtils.lastIndexOf("aabaabaa", 'a') = 7
 StringUtils.lastIndexOf("aabaabaa", 'b') = 5

Parameters:: str - the String to check, may be null; searchChar - the character to find
Returns:: the last index of the search character, -1 if no match or null string input
Since:: 2.0

lastIndexOf

public static int lastIndexOf(String str,
                              char searchChar,
                              int startPos)

Finds the last index within a String from a start position, handling null. This method uses String.lastIndexOf(int, int).

A null or empty ("") String will return -1. A negative start position returns -1. A start position greater than the string length searches the whole string.

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

Parameters:: str - the String to check, may be null; searchChar - the character to find; startPos - the start position
Returns:: the last index of the search character, -1 if no match or null string input
Since:: 2.0

lastIndexOf

public static int lastIndexOf(String str,
                              String searchStr)

Finds the last index within a String, handling null. This method uses String.lastIndexOf(String).

A null String will return -1.

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

Parameters:: str - the String to check, may be null; searchStr - the String to find, may be null
Returns:: the last index of the search String, -1 if no match or null string input
Since:: 2.0

lastIndexOf

public static int lastIndexOf(String str,
                              String searchStr,
                              int startPos)

Finds the first index within a String, handling null. This method uses String.lastIndexOf(String, int).

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

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

Parameters:: str - the String to check, may be null; searchStr - the String to find, may be null; startPos - the start position, negative treated as zero
Returns:: the first index of the search String, -1 if no match or null string input
Since:: 2.0

contains

public static boolean contains(String str,
                               char searchChar)

Checks if String contains a search character, handling null. This method uses String.indexOf(int).

A null or empty ("") String will return false.

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

Parameters:: str - the String to check, may be null; searchChar - the character to find
Returns:: true if the String contains the search character, false if not or null string input
Since:: 2.0

contains

public static boolean contains(String str,
                               String searchStr)

Checks if String contains a search String, handling null. This method uses String.indexOf(String).

A null String 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

Parameters:: str - the String to check, may be null; searchStr - the String to find, may be null
Returns:: true if the String contains the search String, false if not or null string input
Since:: 2.0

containsIgnoreCase

public static boolean containsIgnoreCase(String str,
                                         String searchStr)

Checks if String contains a search String irrespective of case, handling null. This method uses contains(String, String).

A null String 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
 StringUtils.contains("abc", "A") = true
 StringUtils.contains("abc", "Z") = false

Parameters:: str - the String to check, may be null; searchStr - the String to find, may be null
Returns:: true if the String contains the search String irrespective of case or false if not or null string input

indexOfAny

public static int indexOfAny(String str,
                             char[] searchChars)

Search a String 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

Parameters:: str - the String to check, may be null; searchChars - the chars to search for, may be null
Returns:: the index of any of the chars, -1 if no match or null input
Since:: 2.0

indexOfAny

public static int indexOfAny(String str,
                             String searchChars)

Search a String 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

Parameters:: str - the String to check, may be null; searchChars - the chars to search for, may be null
Returns:: the index of any of the chars, -1 if no match or null input
Since:: 2.0

indexOfAnyBut

public static int indexOfAnyBut(String str,
                                char[] searchChars)

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

A null String 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",'za') = 3
 StringUtils.indexOfAnyBut("zzabyycdxx", '')  = 0
 StringUtils.indexOfAnyBut("aba", 'ab')       = -1

Parameters:: str - the String to check, may be null; searchChars - the chars to search for, may be null
Returns:: the index of any of the chars, -1 if no match or null input
Since:: 2.0

indexOfAnyBut

public static int indexOfAnyBut(String str,
                                String searchChars)

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

A null String will return -1. A null 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", "")   = 0
 StringUtils.indexOfAnyBut("aba","ab")         = -1

Parameters:: str - the String to check, may be null; searchChars - the chars to search for, may be null
Returns:: the index of any of the chars, -1 if no match or null input
Since:: 2.0

containsOnly

public static boolean containsOnly(String str,
                                   char[] valid)

Checks if the String contains only certain characters.

A null String will return false. A null valid character array will return false. An empty String ("") 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

Parameters:: str - the String to check, may be null; valid - an array of valid chars, may be null
Returns:: true if it only contains valid chars and is non-null

containsOnly

public static boolean containsOnly(String str,
                                   String validChars)

Checks if the String contains only certain characters.

A null String will return false. A null valid character String will return false. An empty String ("") 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

Parameters:: str - the String to check, may be null; validChars - a String of valid chars, may be null
Returns:: true if it only contains valid chars and is non-null
Since:: 2.0

containsNone

public static boolean containsNone(String str,
                                   char[] invalidChars)

Checks that the String does not contain certain characters.

A null String 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

Parameters:: str - the String to check, may be null; invalidChars - an array of invalid chars, may be null
Returns:: true if it contains none of the invalid chars, or is null
Since:: 2.0

containsNone

public static boolean containsNone(String str,
                                   String invalidChars)

Checks that the String does not contain certain characters.

A null String 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

Parameters:: str - the String to check, may be null; invalidChars - a String of invalid chars, may be null
Returns:: true if it contains none of the invalid chars, or is null
Since:: 2.0

indexOfAny

public static int indexOfAny(String str,
                             String[] searchStrs)

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

A null String 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).

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

Parameters:: str - the String to check, may be null; searchStrs - the Strings to search for, may be null
Returns:: the first index of any of the searchStrs in str, -1 if no match

lastIndexOfAny

public static int lastIndexOfAny(String str,
                                 String[] searchStrs)

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

A null String 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)

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

Parameters:: str - the String to check, may be null; searchStrs - the Strings to search for, may be null
Returns:: the last index of any of the Strings, -1 if no match

substring

public static String substring(String str,
                               int start)

Gets a substring from the specified String avoiding exceptions.

A negative start position can be used to start 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"

Parameters:: 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
Returns:: substring from start position, null if null String input

substring

public static String substring(String str,
                               int start,
                               int end)

Gets a substring from the specified String avoiding exceptions.

A negative start position can be used to start/end 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"

Parameters:: 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
Returns:: substring from start position to end positon, null if null String input

left

public static String left(String str,
                          int len)

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 exception is thrown if len is negative.

 StringUtils.left(null, *)    = null
 StringUtils.left(*, -ve)     = ""
 StringUtils.left("", *)      = ""
 StringUtils.left("abc", 0)   = ""
 StringUtils.left("abc", 2)   = "ab"
 StringUtils.left("abc", 4)   = "abc"

Parameters:: str - the String to get the leftmost characters from, may be null; len - the length of the required String, must be zero or positive
Returns:: the leftmost characters, null if null String input

right

public static String right(String str,
                           int len)

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 exception is thrown if len is negative.

 StringUtils.right(null, *)    = null
 StringUtils.right(*, -ve)     = ""
 StringUtils.right("", *)      = ""
 StringUtils.right("abc", 0)   = ""
 StringUtils.right("abc", 2)   = "bc"
 StringUtils.right("abc", 4)   = "abc"

Parameters:: str - the String to get the rightmost characters from, may be null; len - the length of the required String, must be zero or positive
Returns:: the rightmost characters, null if null String input

mid

public static String mid(String str,
                         int pos,
                         int len)

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 exception is thrown if len is negative.

 StringUtils.mid(null, *, *)    = null
 StringUtils.mid(*, *, -ve)     = ""
 StringUtils.mid("", 0, *)      = ""
 StringUtils.mid("abc", 0, 2)   = "ab"
 StringUtils.mid("abc", 0, 4)   = "abc"
 StringUtils.mid("abc", 2, 4)   = "c"
 StringUtils.mid("abc", 4, 2)   = ""
 StringUtils.mid("abc", -2, 2)  = "ab"

Parameters:: str - the String to get the characters from, may be null; pos - the position to start from, negative treated as zero; len - the length of the required String, must be zero or positive
Returns:: the middle characters, null if null String input

substringBefore

public static String substringBefore(String str,
                                     String separator)

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.

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

Parameters:: str - the String to get a substring from, may be null; separator - the String to search for, may be null
Returns:: the substring before the first occurrence of the separator, null if null String input
Since:: 2.0

substringAfter

public static String substringAfter(String str,
                                    String separator)

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.

 StringUtils.substringAfter(null, *)      = null
 StringUtils.substringAfter("", *)        = ""
 StringUtils.substringAfter(*, null)      = ""
 StringUtils.substringAfter("abc", "a")   = "bc"
 StringUtils.substringAfter("abcba", "b") = "cba"
 StringUtils.substringAfter("abc", "c")   = ""
 StringUtils.substringAfter("abc", "d")   = ""
 StringUtils.substringAfter("abc", "")    = "abc"

Parameters:: str - the String to get a substring from, may be null; separator - the String to search for, may be null
Returns:: the substring after the first occurrence of the separator, null if null String input
Since:: 2.0

substringBeforeLast

public static String substringBeforeLast(String str,
                                         String separator)

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.

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

Parameters:: str - the String to get a substring from, may be null; separator - the String to search for, may be null
Returns:: the substring before the last occurrence of the separator, null if null String input
Since:: 2.0

substringAfterLast

public static String substringAfterLast(String str,
                                        String separator)

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.

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

Parameters:: str - the String to get a substring from, may be null; separator - the String to search for, may be null
Returns:: the substring after the last occurrence of the separator, null if null String input
Since:: 2.0

substringBetween

public static String substringBetween(String str,
                                      String tag)

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"

Parameters:: str - the String containing the substring, may be null; tag - the String before and after the substring, may be null
Returns:: the substring, null if no match
Since:: 2.0

substringBetween

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

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

A 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"

Parameters:: str - the String containing the substring, may be null; open - the String before the substring, may be null; close - the String after the substring, may be null
Returns:: the substring, null if no match
Since:: 2.0

substringsBetween

public static String[] substringsBetween(String str,
                                         String open,
                                         String close)

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

A 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("", "[", "]")          = []

Parameters:: str - the String containing the substrings, null returns null, empty returns empty; open - the String identifying the start of the substring, empty returns null; close - the String identifying the end of the substring, empty returns null
Returns:: a String Array of substrings, or null if no match
Since:: 2.3

getNestedString

public static String getNestedString(String str,
                                     String tag)

Deprecated. Use the better named substringBetween(String, String). Method will be removed in Commons Lang 3.0.

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.getNestedString(null, *)            = null
 StringUtils.getNestedString("", "")             = ""
 StringUtils.getNestedString("", "tag")          = null
 StringUtils.getNestedString("tagabctag", null)  = null
 StringUtils.getNestedString("tagabctag", "")    = ""
 StringUtils.getNestedString("tagabctag", "tag") = "abc"

Parameters:: str - the String containing nested-string, may be null; tag - the String before and after nested-string, may be null
Returns:: the nested String, null if no match

getNestedString

public static String getNestedString(String str,
                                     String open,
                                     String close)

Deprecated. Use the better named substringBetween(String, String, String). Method will be removed in Commons Lang 3.0.

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/close returns an empty string.

 StringUtils.getNestedString(null, *, *)          = null
 StringUtils.getNestedString("", "", "")          = ""
 StringUtils.getNestedString("", "", "tag")       = null
 StringUtils.getNestedString("", "tag", "tag")    = null
 StringUtils.getNestedString("yabcz", null, null) = null
 StringUtils.getNestedString("yabcz", "", "")     = ""
 StringUtils.getNestedString("yabcz", "y", "z")   = "abc"
 StringUtils.getNestedString("yabczyabcz", "y", "z")   = "abc"

Parameters:: str - the String containing nested-string, may be null; open - the String before nested-string, may be null; close - the String after nested-string, may be null
Returns:: the nested String, null if no match

split

public static String[] split(String str)

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"]

Parameters:: str - the String to parse, may be null
Returns:: an array of parsed Strings, null if null String input

split

public static String[] split(String str,
                             char separatorChar)

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

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

A 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\tb\nc", null) = ["a", "b", "c"]
 StringUtils.split("a b c", ' ')    = ["a", "b", "c"]

Parameters:: str - the String to parse, may be null; separatorChar - the character used as the delimiter, null splits on whitespace
Returns:: an array of parsed Strings, null if null String input
Since:: 2.0

split

public static String[] split(String str,
                             String separatorChars)

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

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

A 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"]

Parameters:: str - the String to parse, may be null; separatorChars - the characters used as the delimiters, null splits on whitespace
Returns:: an array of parsed Strings, null if null String input

split

public static String[] split(String str,
                             String separatorChars,
                             int max)

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

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

A 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 de fg", null, 0)   = ["ab", "cd", "ef"]
 StringUtils.split("ab   de fg", null, 0) = ["ab", "cd", "ef"]
 StringUtils.split("ab:cd:ef", ":", 0)    = ["ab", "cd", "ef"]
 StringUtils.split("ab:cd:ef", ":", 2)    = ["ab", "cd:ef"]

Parameters:: str - the String to parse, may be null; separatorChars - the characters used as the delimiters, null splits on whitespace; max - the maximum number of elements to include in the array. A zero or negative value implies no limit
Returns:: an array of parsed Strings, null if null String input

splitByWholeSeparator

public static String[] splitByWholeSeparator(String str,
                                             String separator)

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

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

A 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"]

Parameters:: str - the String to parse, may be null; separator - String containing the String to be used as a delimiter, null splits on whitespace
Returns:: an array of parsed Strings, null if null String was input

splitByWholeSeparator

public static String[] splitByWholeSeparator(String str,
                                             String separator,
                                             int max)

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"]

Parameters:: 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.
Returns:: an array of parsed Strings, null if null String was input

splitPreserveAllTokens

public static String[] splitPreserveAllTokens(String str)

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", ""]

Parameters:: str - the String to parse, may be null
Returns:: an array of parsed Strings, null if null String input
Since:: 2.1

splitPreserveAllTokens

public static String[] splitPreserveAllTokens(String str,
                                              char separatorChar)

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", ""]

Parameters:: str - the String to parse, may be null; separatorChar - the character used as the delimiter, null splits on whitespace
Returns:: an array of parsed Strings, null if null String input
Since:: 2.1

splitPreserveAllTokens

public static String[] splitPreserveAllTokens(String str,
                                              String separatorChars)

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", ""]

Parameters:: str - the String to parse, may be null; separatorChars - the characters used as the delimiters, null splits on whitespace
Returns:: an array of parsed Strings, null if null String input
Since:: 2.1

splitPreserveAllTokens

public static String[] splitPreserveAllTokens(String str,
                                              String separatorChars,
                                              int max)

Splits the provided text into an array with a maximum length, separators specified, preserving all tokens, including empty 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", "cd", "ef"]
 StringUtils.splitPreserveAllTokens("ab   de fg", null, 0) = ["ab", "cd", "ef"]
 StringUtils.splitPreserveAllTokens("ab:cd:ef", ":", 0)    = ["ab", "cd", "ef"]
 StringUtils.splitPreserveAllTokens("ab:cd:ef", ":", 2)    = ["ab", "cd:ef"]
 StringUtils.splitPreserveAllTokens("ab   de fg", null, 2) = ["ab", "  de fg"]
 StringUtils.splitPreserveAllTokens("ab   de fg", null, 3) = ["ab", "", " de fg"]
 StringUtils.splitPreserveAllTokens("ab   de fg", null, 4) = ["ab", "", "", "de fg"]

Parameters:: str - the String to parse, may be 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
Returns:: an array of parsed Strings, null if null String input
Since:: 2.1

concatenate

public static String concatenate(Object[] array)

Deprecated. Use the better named join(Object[]) instead. Method will be removed in Commons Lang 3.0.

Concatenates elements of an array into a single String. Null objects or empty strings within the array are represented by empty strings.

 StringUtils.concatenate(null)            = null
 StringUtils.concatenate([])              = ""
 StringUtils.concatenate([null])          = ""
 StringUtils.concatenate(["a", "b", "c"]) = "abc"
 StringUtils.concatenate([null, "", "a"]) = "a"

Parameters:: array - the array of values to concatenate, may be null
Returns:: the concatenated String, null if null array input