since: 2.0 -

since: 2.1 -

 public StringUtils() 
{
        super();
}

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.

 public static String abbreviate(String str,
    int maxWidth) 
{
        return abbreviate(str, 0, maxWidth);
}

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

Specifically:

• If str is less than maxWidth characters long, return it.
• Else abbreviate it to (substring(str, 0, max-3) + "...").
• If maxWidth is less than 4, throw an IllegalArgumentException.
• In no case will it return a String of length greater than 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

 public static String abbreviate(String str,
    int offset,
    int maxWidth) 
{
        if (str == null) {
            return null;
        }
        if (maxWidth <  4) {
            throw new IllegalArgumentException("Minimum abbreviation width is 4");
        }
        if (str.length() < = maxWidth) {
            return str;
        }
        if (offset  > str.length()) {
            offset = str.length();
        }
        if ((str.length() - offset) <  (maxWidth - 3)) {
            offset = str.length() - (maxWidth - 3);
        }
        if (offset < = 4) {
            return str.substring(0, maxWidth - 3) + "...";
        }
        if (maxWidth <  7) {
            throw new IllegalArgumentException("Minimum abbreviation width with offset is 7");
        }
        if ((offset + (maxWidth - 3)) <  str.length()) {
            return "..." + abbreviate(str.substring(offset), maxWidth - 3);
        }
        return "..." + str.substring(str.length() - (maxWidth - 3));
}

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

 public static String abbreviateMiddle(String str,
    String middle,
    int length) 
{
        if (isEmpty(str) || isEmpty(middle)) {
            return str;
        }
        if (length  >= str.length() || length <  (middle.length()+2)) {
            return str;
        }
        int targetSting = length-middle.length();
        int startOffset = targetSting/2+targetSting%2;
        int endOffset = str.length()-targetSting/2;
        StringBuffer builder = new StringBuffer(length);
        builder.append(str.substring(0,startOffset));
        builder.append(middle);
        builder.append(str.substring(endOffset));
        return builder.toString();
}

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:

• Neither the String for abbreviation nor the replacement String are null or empty
• The length to truncate to is less than the length of the supplied String
• The length to truncate to is greater than 0
• The abbreviated String will have enough room for the length supplied replacement String and the first and last characters of the supplied String for abbreviation
Otherwise, the returned String will be the same as the supplied String for abbreviation.

StringUtils.abbreviateMiddle(null, null, 0)      = null
StringUtils.abbreviateMiddle("abc", null, 0)      = "abc"
StringUtils.abbreviateMiddle("abc", ".", 0)      = "abc"
StringUtils.abbreviateMiddle("abc", ".", 3)      = "abc"
StringUtils.abbreviateMiddle("abcdef", ".", 4)     = "ab.f"

 public static String capitalise(String str) 
{
        return capitalize(str);
}

Capitalizes a String changing the first letter to title case as per Character#toTitleCase(char) . No other letters are changed.

 public static String capitaliseAllWords(String str) 
{
        return WordUtils.capitalize(str);
}

Capitalizes all the whitespace separated words in a String. Only the first letter of each word is changed.

Whitespace is defined by Character#isWhitespace(char) . A null input String returns null.

 public static String capitalize(String str) 
{
        int strLen;
        if (str == null || (strLen = str.length()) == 0) {
            return str;
        }
        return new StringBuffer(strLen)
            .append(Character.toTitleCase(str.charAt(0)))
            .append(str.substring(1))
            .toString();
}

Capitalizes a String changing the first letter to title case as per Character#toTitleCase(char) . No other letters 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"

 public static String center(String str,
    int size) 
{
        return center(str, size, ' ');
}

Centers a String in a larger String of size size using the space character (' ').

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.

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  "

 public static String center(String str,
    int size,
    char padChar) 
{
        if (str == null || size < = 0) {
            return str;
        }
        int strLen = str.length();
        int pads = size - strLen;
        if (pads < = 0) {
            return str;
        }
        str = leftPad(str, strLen + pads / 2, padChar);
        str = rightPad(str, size, padChar);
        return str;
}

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"

 public static String center(String str,
    int size,
    String padStr) 
{
        if (str == null || size < = 0) {
            return str;
        }
        if (isEmpty(padStr)) {
            padStr = " ";
        }
        int strLen = str.length();
        int pads = size - strLen;
        if (pads < = 0) {
            return str;
        }
        str = leftPad(str, strLen + pads / 2, padStr);
        str = rightPad(str, size, padStr);
        return str;
}

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  "

 public static String chomp(String str) 
{
        if (isEmpty(str)) {
            return str;
        }
        if (str.length() == 1) {
            char ch = str.charAt(0);
            if (ch == CharUtils.CR || ch == CharUtils.LF) {
                return EMPTY;
            }
            return str;
        }
        int lastIdx = str.length() - 1;
        char last = str.charAt(lastIdx);
        if (last == CharUtils.LF) {
            if (str.charAt(lastIdx - 1) == CharUtils.CR) {
                lastIdx--;
            }
        } else if (last != CharUtils.CR) {
            lastIdx++;
        }
        return str.substring(0, lastIdx);
}

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")        = ""

 public static String chomp(String str,
    String separator) 
{
        if (isEmpty(str) || separator == null) {
            return str;
        }
        if (str.endsWith(separator)) {
            return str.substring(0, str.length() - separator.length());
        }
        return str;
}

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"

 public static String chompLast(String str) 
{
        return chompLast(str, "\n");
}

Remove any "\n" if and only if it is at the end of the supplied String.

 public static String chompLast(String str,
    String sep) 
{
        if (str.length() == 0) {
            return str;
        }
        String sub = str.substring(str.length() - sep.length());
        if (sep.equals(sub)) {
            return str.substring(0, str.length() - sep.length());
        }
        return str;
}

Remove a value if and only if the String ends with that value.

 public static String chop(String str) 
{
        if (str == null) {
            return null;
        }
        int strLen = str.length();
        if (strLen <  2) {
            return EMPTY;
        }
        int lastIdx = strLen - 1;
        String ret = str.substring(0, lastIdx);
        char last = str.charAt(lastIdx);
        if (last == CharUtils.LF) {
            if (ret.charAt(lastIdx - 1) == CharUtils.CR) {
                return ret.substring(0, lastIdx - 1);
            }
        }
        return ret;
}

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")        = ""

 public static String chopNewline(String str) 
{
        int lastIdx = str.length() - 1;
        if (lastIdx < = 0) {
            return EMPTY;
        }
        char last = str.charAt(lastIdx);
        if (last == CharUtils.LF) {
            if (str.charAt(lastIdx - 1) == CharUtils.CR) {
                lastIdx--;
            }
        } else {
            lastIdx++;
        }
        return str.substring(0, lastIdx);
}

Removes \n from end of a String if it's there. If a \r precedes it, then remove that too.

 public static String clean(String str) 
{
        return str == null ? EMPTY : str.trim();
}

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("     ")       = ""

 public static String concatenate(Object[] array) 
{
        return join(array, null);
}

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"

 public static boolean contains(String str,
    char searchChar) 
{
        if (isEmpty(str)) {
            return false;
        }
        return str.indexOf(searchChar)  >= 0;
}

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

 public static boolean contains(String str,
    String searchStr) 
{
        if (str == null || searchStr == null) {
            return false;
        }
        return str.indexOf(searchStr)  >= 0;
}

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

 public static boolean containsAny(String str,
    char[] searchChars) 
{
        if (str == null || str.length() == 0 || searchChars == null || searchChars.length == 0) {
            return false;
        }
        for (int i = 0; i <  str.length(); i++) {
            char ch = str.charAt(i);
            for (int j = 0; j <  searchChars.length; j++) {
                if (searchChars[j] == ch) {
                    return true;
                }
            }
        }
        return false;
}

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

A null String 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("aba", ['z'])           = false

 public static boolean containsAny(String str,
    String searchChars) 
{
        if (searchChars == null) {
            return false;
        }
        return containsAny(str, searchChars.toCharArray());
}

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

A null String will return false. A null search string 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("aba","z")          = false

 public static boolean containsIgnoreCase(String str,
    String searchStr) 
{
        if (str == null || searchStr == null) {
            return false;
        }
        int len = searchStr.length();
        int max = str.length() - len;
        for (int i = 0; i < = max; i++) {
            if (str.regionMatches(true, i, searchStr, 0, len)) {
                return true;
            }
        }
        return false;
}

Checks if String contains a search String irrespective of case, handling null. Case-insensitivity is defined as by String#equalsIgnoreCase(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

 public static boolean containsNone(String str,
    char[] invalidChars) 
{
        if (str == null || invalidChars == null) {
            return true;
        }
        int strSize = str.length();
        int validSize = invalidChars.length;
        for (int i = 0; i <  strSize; i++) {
            char ch = str.charAt(i);
            for (int j = 0; j <  validSize; j++) {
                if (invalidChars[j] == ch) {
                    return false;
                }
            }
        }
        return true;
}

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

 public static boolean containsNone(String str,
    String invalidChars) 
{
        if (str == null || invalidChars == null) {
            return true;
        }
        return containsNone(str, invalidChars.toCharArray());
}

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

 public static boolean containsOnly(String str,
    char[] valid) 
{
        // All these pre-checks are to maintain API with an older version
        if ((valid == null) || (str == null)) {
            return false;
        }
        if (str.length() == 0) {
            return true;
        }
        if (valid.length == 0) {
            return false;
        }
        return indexOfAnyBut(str, valid) == -1;
}

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

 public static boolean containsOnly(String str,
    String validChars) 
{
        if (str == null || validChars == null) {
            return false;
        }
        return containsOnly(str, validChars.toCharArray());
}

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

 public static int countMatches(String str,
    String sub) 
{
        if (isEmpty(str) || isEmpty(sub)) {
            return 0;
        }
        int count = 0;
        int idx = 0;
        while ((idx = str.indexOf(sub, idx)) != -1) {
            count++;
            idx += sub.length();
        }
        return count;
}

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

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

 public static String defaultIfEmpty(String str,
    String defaultStr) 
{
        return StringUtils.isEmpty(str) ? defaultStr : str;
}

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

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

 public static String defaultString(String str) 
{
        return str == null ? EMPTY : str;
}

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

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

 public static String defaultString(String str,
    String defaultStr) 
{
        return str == null ? defaultStr : str;
}

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

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

 public static String deleteSpaces(String str) 
{
        if (str == null) {
            return null;
        }
        return CharSetUtils.delete(str, " \t\r\n\b");
}

Deletes all 'space' characters from a String as defined by Character#isSpace(char) .

This is the only StringUtils method that uses the isSpace definition. You are advised to use #deleteWhitespace(String) instead as whitespace is much better localized.

StringUtils.deleteSpaces(null)           = null
StringUtils.deleteSpaces("")             = ""
StringUtils.deleteSpaces("abc")          = "abc"
StringUtils.deleteSpaces(" \t  abc \n ") = "abc"
StringUtils.deleteSpaces("ab  c")        = "abc"
StringUtils.deleteSpaces("a\nb\tc     ") = "abc"

Spaces are defined as {' ', '\t', '\r', '\n', '\b'} in line with the deprecated isSpace method.

 public static String deleteWhitespace(String str) 
{
        if (isEmpty(str)) {
            return str;
        }
        int sz = str.length();
        char[] chs = new char[sz];
        int count = 0;
        for (int i = 0; i <  sz; i++) {
            if (!Character.isWhitespace(str.charAt(i))) {
                chs[count++] = str.charAt(i);
            }
        }
        if (count == sz) {
            return str;
        }
        return new String(chs, 0, count);
}

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"

 public static String difference(String str1,
    String str2) 
{
        if (str1 == null) {
            return str2;
        }
        if (str2 == null) {
            return str1;
        }
        int at = indexOfDifference(str1, str2);
        if (at == -1) {
            return EMPTY;
        }
        return str2.substring(at);
}

Compares two Strings, and returns the portion where they differ. (More precisely, return the remainder of the second String, starting from where it's different from the first.)

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

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

 public static boolean endsWith(String str,
    String suffix) 
{
        return endsWith(str, suffix, false);
}

Check if a String 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

 public static boolean endsWithIgnoreCase(String str,
    String suffix) 
{
        return endsWith(str, suffix, true);
}

Case insensitive check if a String 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

 public static boolean equals(String str1,
    String str2) 
{
        return str1 == null ? str2 == null : str1.equals(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

 public static boolean equalsIgnoreCase(String str1,
    String str2) 
{
        return str1 == null ? str2 == null : str1.equalsIgnoreCase(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

 public static String escape(String str) 
{
        return StringEscapeUtils.escapeJava(str);
}

Escapes any values it finds into their String form.

So a tab becomes the characters '\\' and 't'.

As of Lang 2.0, this calls StringEscapeUtils#escapeJava(String) behind the scenes.

 public static String getChomp(String str,
    String sep) 
{
        int idx = str.lastIndexOf(sep);
        if (idx == str.length() - sep.length()) {
            return sep;
        } else if (idx != -1) {
            return str.substring(idx);
        } else {
            return EMPTY;
        }
}

Remove everything and return the last value of a supplied String, and everything after it from a String.

 public static String getCommonPrefix(String[] strs) 
{
        if (strs == null || strs.length == 0) {
            return EMPTY;
        }
        int smallestIndexOfDiff = indexOfDifference(strs);
        if (smallestIndexOfDiff == -1) {
            // all strings were identical
            if (strs[0] == null) {
                return EMPTY;
            }
            return strs[0];
        } else if (smallestIndexOfDiff == 0) {
            // there were no common initial characters
            return EMPTY;
        } else {
            // we found a common initial character sequence
            return strs[0].substring(0, smallestIndexOfDiff);
        }
}

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 "

 public static int getLevenshteinDistance(String s,
    String t) 
{
        if (s == null || t == null) {
            throw new IllegalArgumentException("Strings must not be null");
        }
        /*
           The difference between this impl. and the previous is that, rather 
           than creating and retaining a matrix of size s.length()+1 by t.length()+1, 
           we maintain two single-dimensional arrays of length s.length()+1.  The first, d,
           is the 'current working' distance array that maintains the newest distance cost
           counts as we iterate through the characters of String s.  Each time we increment
           the index of String t we are comparing, d is copied to p, the second int[].  Doing so
           allows us to retain the previous cost counts as required by the algorithm (taking 
           the minimum of the cost count to the left, up one, and diagonally up and to the left
           of the current cost count being calculated).  (Note that the arrays aren't really 
           copied anymore, just switched...this is clearly much better than cloning an array 
           or doing a System.arraycopy() each time  through the outer loop.)
           Effectively, the difference between the two implementations is this one does not 
           cause an out of memory condition when calculating the LD over two very large strings.
         */
        int n = s.length(); // length of s
        int m = t.length(); // length of t
        if (n == 0) {
            return m;
        } else if (m == 0) {
            return n;
        }
        if (n  > m) {
            // swap the input strings to consume less memory
            String tmp = s;
            s = t;
            t = tmp;
            n = m;
            m = t.length();
        }
        int p[] = new int[n+1]; //'previous' cost array, horizontally
        int d[] = new int[n+1]; // cost array, horizontally
        int _d[]; //placeholder to assist in swapping p and d
        // indexes into strings s and t
        int i; // iterates through s
        int j; // iterates through t
        char t_j; // jth character of t
        int cost; // cost
        for (i = 0; i< =n; i++) {
            p[i] = i;
        }
        for (j = 1; j< =m; j++) {
            t_j = t.charAt(j-1);
            d[0] = j;
            for (i=1; i< =n; i++) {
                cost = s.charAt(i-1)==t_j ? 0 : 1;
                // minimum of cell to the left+1, to the top+1, diagonally left and up +cost
                d[i] = Math.min(Math.min(d[i-1]+1, p[i]+1),  p[i-1]+cost);
            }
            // copy current distance counts to 'previous row' distance counts
            _d = p;
            p = d;
            d = _d;
        }
        // our last action in the above loop was to switch d and p, so p now 
        // actually has the most recent cost counts
        return p[n];
}

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 previous implementation of the Levenshtein distance algorithm was from http://www.merriampark.com/ld.htm

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

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

 public static String getNestedString(String str,
    String tag) 
{
        return substringBetween(str, tag, 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.getNestedString(null, *)            = null
StringUtils.getNestedString("", "")             = ""
StringUtils.getNestedString("", "tag")          = null
StringUtils.getNestedString("tagabctag", null)  = null
StringUtils.getNestedString("tagabctag", "")    = ""
StringUtils.getNestedString("tagabctag", "tag") = "abc"

 public static String getNestedString(String str,
    String open,
    String close) 
{
        return substringBetween(str, open, 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/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"

 public static String getPrechomp(String str,
    String sep) 
{
        int idx = str.indexOf(sep);
        if (idx == -1) {
            return EMPTY;
        } 
        return str.substring(0, idx + sep.length());
}

Remove and return everything before the first value of a supplied String from another String.

 public static int indexOf(String str,
    char searchChar) 
{
        if (isEmpty(str)) {
            return -1;
        }
        return str.indexOf(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

 public static int indexOf(String str,
    String searchStr) 
{
        if (str == null || searchStr == null) {
            return -1;
        }
        return str.indexOf(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

 public static int indexOf(String str,
    char searchChar,
    int startPos) 
{
        if (isEmpty(str)) {
            return -1;
        }
        return str.indexOf(searchChar, 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

 public static int indexOf(String str,
    String searchStr,
    int startPos) 
{
        if (str == null || searchStr == null) {
            return -1;
        }
        // JDK1.2/JDK1.3 have a bug, when startPos  > str.length for "", hence
        if (searchStr.length() == 0 && startPos  >= str.length()) {
            return str.length();
        }
        return str.indexOf(searchStr, 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

 public static int indexOfAny(String str,
    char[] searchChars) 
{
        if (isEmpty(str) || ArrayUtils.isEmpty(searchChars)) {
            return -1;
        }
        for (int i = 0; i <  str.length(); i++) {
            char ch = str.charAt(i);
            for (int j = 0; j <  searchChars.length; j++) {
                if (searchChars[j] == ch) {
                    return i;
                }
            }
        }
        return -1;
}

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

 public static int indexOfAny(String str,
    String searchChars) 
{
        if (isEmpty(str) || isEmpty(searchChars)) {
            return -1;
        }
        return indexOfAny(str, searchChars.toCharArray());
}

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

 public static int indexOfAny(String str,
    String[] searchStrs) 
{
        if ((str == null) || (searchStrs == null)) {
            return -1;
        }
        int sz = searchStrs.length;
        // String's can't have a MAX_VALUEth index.
        int ret = Integer.MAX_VALUE;
        int tmp = 0;
        for (int i = 0; i <  sz; i++) {
            String search = searchStrs[i];
            if (search == null) {
                continue;
            }
            tmp = str.indexOf(search);
            if (tmp == -1) {
                continue;
            }
            if (tmp <  ret) {
                ret = tmp;
            }
        }
        return (ret == Integer.MAX_VALUE) ? -1 : ret;
}

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

 public static int indexOfAnyBut(String str,
    char[] searchChars) 
{
        if (isEmpty(str) || ArrayUtils.isEmpty(searchChars)) {
            return -1;
        }
        outer : for (int i = 0; i <  str.length(); i++) {
            char ch = str.charAt(i);
            for (int j = 0; j <  searchChars.length; j++) {
                if (searchChars[j] == ch) {
                    continue outer;
                }
            }
            return i;
        }
        return -1;
}

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

 public static int indexOfAnyBut(String str,
    String searchChars) 
{
        if (isEmpty(str) || isEmpty(searchChars)) {
            return -1;
        }
        for (int i = 0; i <  str.length(); i++) {
            if (searchChars.indexOf(str.charAt(i)) <  0) {
                return i;
            }
        }
        return -1;
}

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

 public static int indexOfDifference(String[] strs) 
{
        if (strs == null || strs.length < = 1) {
            return -1;
        }
        boolean anyStringNull = false;
        boolean allStringsNull = true;
        int arrayLen = strs.length;
        int shortestStrLen = Integer.MAX_VALUE;
        int longestStrLen = 0;
        // find the min and max string lengths; this avoids checking to make
        // sure we are not exceeding the length of the string each time through
        // the bottom loop.
        for (int i = 0; i <  arrayLen; i++) {
            if (strs[i] == null) {
                anyStringNull = true;
                shortestStrLen = 0;
            } else {
                allStringsNull = false;
                shortestStrLen = Math.min(strs[i].length(), shortestStrLen);
                longestStrLen = Math.max(strs[i].length(), longestStrLen);
            }
        }
        // handle lists containing all nulls or all empty strings
        if (allStringsNull || (longestStrLen == 0 && !anyStringNull)) {
            return -1;
        }
        // handle lists containing some nulls or some empty strings
        if (shortestStrLen == 0) {
            return 0;
        }
        // find the position with the first difference across all strings
        int firstDiff = -1;
        for (int stringPos = 0; stringPos <  shortestStrLen; stringPos++) {
            char comparisonChar = strs[0].charAt(stringPos);
            for (int arrayPos = 1; arrayPos <  arrayLen; arrayPos++) {
                if (strs[arrayPos].charAt(stringPos) != comparisonChar) {
                    firstDiff = stringPos;
                    break;
                }
            }
            if (firstDiff != -1) {
                break;
            }
        }
        if (firstDiff == -1 && shortestStrLen != longestStrLen) {
            // we compared all of the characters up to the length of the
            // shortest string and didn't find a match, but the string lengths
            // vary, so return the length of the shortest string.
            return shortestStrLen;
        }
        return firstDiff;
}

Compares all Strings in an array and returns the index at which the Strings 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

 public static int indexOfDifference(String str1,
    String str2) 
{
        if (str1 == str2) {
            return -1;
        }
        if (str1 == null || str2 == null) {
            return 0;
        }
        int i;
        for (i = 0; i <  str1.length() && i <  str2.length(); ++i) {
            if (str1.charAt(i) != str2.charAt(i)) {
                break;
            }
        }
        if (i <  str2.length() || i <  str1.length()) {
            return i;
        }
        return -1;
}

Compares two Strings, and returns the index at which the Strings 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

 public static int indexOfIgnoreCase(String str,
    String searchStr) 
{
        return indexOfIgnoreCase(str, searchStr, 0);
}

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

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.indexOfIgnoreCase(null, *)          = -1
StringUtils.indexOfIgnoreCase(*, null)          = -1
StringUtils.indexOfIgnoreCase("", "")           = 0
StringUtils.indexOfIgnoreCase("aabaabaa", "a")  = 0
StringUtils.indexOfIgnoreCase("aabaabaa", "b")  = 2
StringUtils.indexOfIgnoreCase("aabaabaa", "ab") = 1

 public static int indexOfIgnoreCase(String str,
    String searchStr,
    int startPos) 
{
        if (str == null || searchStr == null) {
            return -1;
        }
        if (startPos <  0) {
            startPos = 0;
        }
        int endLimit = (str.length() - searchStr.length()) + 1;
        if (startPos  > endLimit) {
            return -1;
        }
        if (searchStr.length() == 0) {
            return startPos;
        }
        for (int i = startPos; i <  endLimit; i++) {
            if (str.regionMatches(true, i, searchStr, 0, searchStr.length())) {
                return i;
            }
        }
        return -1;
}

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

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.indexOfIgnoreCase(null, *, *)          = -1
StringUtils.indexOfIgnoreCase(*, null, *)          = -1
StringUtils.indexOfIgnoreCase("", "", 0)           = 0
StringUtils.indexOfIgnoreCase("aabaabaa", "A", 0)  = 0
StringUtils.indexOfIgnoreCase("aabaabaa", "B", 0)  = 2
StringUtils.indexOfIgnoreCase("aabaabaa", "AB", 0) = 1
StringUtils.indexOfIgnoreCase("aabaabaa", "B", 3)  = 5
StringUtils.indexOfIgnoreCase("aabaabaa", "B", 9)  = -1
StringUtils.indexOfIgnoreCase("aabaabaa", "B", -1) = 2
StringUtils.indexOfIgnoreCase("aabaabaa", "", 2)   = 2
StringUtils.indexOfIgnoreCase("abc", "", 9)        = 3

 public static boolean isAllLowerCase(String str) 
{
        if (str == null || isEmpty(str)) {
            return false;
        }
        int sz = str.length();
        for (int i = 0; i <  sz; i++) {
            if (Character.isLowerCase(str.charAt(i)) == false) {
                return false;
            }
        }
        return true;
}

Checks if the String contains only lowercase characters.

null will return false. An empty String ("") will return false.

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

 public static boolean isAllUpperCase(String str) 
{
        if (str == null || isEmpty(str)) {
            return false;
        }
        int sz = str.length();
        for (int i = 0; i <  sz; i++) {
            if (Character.isUpperCase(str.charAt(i)) == false) {
                return false;
            }
        }
        return true;
}

Checks if the String contains only uppercase characters.

null will return false. An empty String ("") will return false.

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

 public static boolean isAlpha(String str) 
{
        if (str == null) {
            return false;
        }
        int sz = str.length();
        for (int i = 0; i <  sz; i++) {
            if (Character.isLetter(str.charAt(i)) == false) {
                return false;
            }
        }
        return true;
}

Checks if the String contains only unicode letters.

null will return false. An empty String ("") will return true.

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

 public static boolean isAlphaSpace(String str) 
{
        if (str == null) {
            return false;
        }
        int sz = str.length();
        for (int i = 0; i <  sz; i++) {
            if ((Character.isLetter(str.charAt(i)) == false) && (str.charAt(i) != ' ')) {
                return false;
            }
        }
        return true;
}

Checks if the String contains only unicode letters and space (' ').

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

 public static boolean isAlphanumeric(String str) 
{
        if (str == null) {
            return false;
        }
        int sz = str.length();
        for (int i = 0; i <  sz; i++) {
            if (Character.isLetterOrDigit(str.charAt(i)) == false) {
                return false;
            }
        }
        return true;
}

Checks if the String contains only unicode letters or digits.

null will return false. An empty String ("") will return true.

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

 public static boolean isAlphanumericSpace(String str) 
{
        if (str == null) {
            return false;
        }
        int sz = str.length();
        for (int i = 0; i <  sz; i++) {
            if ((Character.isLetterOrDigit(str.charAt(i)) == false) && (str.charAt(i) != ' ')) {
                return false;
            }
        }
        return true;
}

Checks if the String contains only unicode letters, digits or space (' ').

null will return false. An empty String ("") will return true.

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

 public static boolean isAsciiPrintable(String str) 
{
        if (str == null) {
            return false;
        }
        int sz = str.length();
        for (int i = 0; i <  sz; i++) {
            if (CharUtils.isAsciiPrintable(str.charAt(i)) == false) {
                return false;
            }
        }
        return true;
}

Checks if the string contains only ASCII printable characters.

null will return false. An empty String ("") 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("\u0020") = true
StringUtils.isAsciiPrintable("\u0021") = true
StringUtils.isAsciiPrintable("\u007e") = true
StringUtils.isAsciiPrintable("\u007f") = false
StringUtils.isAsciiPrintable("Ceki G\u00fclc\u00fc") = false

 public static boolean isBlank(String str) 
{
        int strLen;
        if (str == null || (strLen = str.length()) == 0) {
            return true;
        }
        for (int i = 0; i <  strLen; i++) {
            if ((Character.isWhitespace(str.charAt(i)) == false)) {
                return false;
            }
        }
        return true;
}

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

 public static boolean isEmpty(String str) 
{
        return str == null || str.length() == 0;
}

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

 public static boolean isNotBlank(String str) 
{
        return !StringUtils.isBlank(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

 public static boolean isNotEmpty(String str) 
{
        return !StringUtils.isEmpty(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

 public static boolean isNumeric(String str) 
{
        if (str == null) {
            return false;
        }
        int sz = str.length();
        for (int i = 0; i <  sz; i++) {
            if (Character.isDigit(str.charAt(i)) == false) {
                return false;
            }
        }
        return true;
}

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

null will return false. An empty String ("") will return true.

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

 public static boolean isNumericSpace(String str) 
{
        if (str == null) {
            return false;
        }
        int sz = str.length();
        for (int i = 0; i <  sz; i++) {
            if ((Character.isDigit(str.charAt(i)) == false) && (str.charAt(i) != ' ')) {
                return false;
            }
        }
        return true;
}

Checks if the String contains only unicode digits or space (' '). A decimal point is not a unicode digit and returns false.

null will return false. An empty String ("") will return true.

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

 public static boolean isWhitespace(String str) 
{
        if (str == null) {
            return false;
        }
        int sz = str.length();
        for (int i = 0; i <  sz; i++) {
            if ((Character.isWhitespace(str.charAt(i)) == false)) {
                return false;
            }
        }
        return true;
}

Checks if the String contains only whitespace.

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

 public static String join(Object[] array) 
{
        return join(array, null);
}

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"

 public static String join(Object[] array,
    char separator) 
{
        if (array == null) {
            return null;
        }
        return join(array, separator, 0, 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(["a", "b", "c"], ';')  = "a;b;c"
StringUtils.join(["a", "b", "c"], null) = "abc"
StringUtils.join([null, "", "a"], ';')  = ";;a"

 public static String join(Object[] array,
    String separator) 
{
        if (array == null) {
            return null;
        }
        return join(array, separator, 0, 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. 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"

 public static String join(Iterator iterator,
    char separator) 
{
        // handle null, zero and one elements before building a buffer
        if (iterator == null) {
            return null;
        }
        if (!iterator.hasNext()) {
            return EMPTY;
        }
        Object first = iterator.next();
        if (!iterator.hasNext()) {
            return ObjectUtils.toString(first);
        }
        // two or more elements
        StringBuffer buf = new StringBuffer(256); // Java default is 16, probably too small
        if (first != null) {
            buf.append(first);
        }
        while (iterator.hasNext()) {
            buf.append(separator);
            Object obj = iterator.next();
            if (obj != null) {
                buf.append(obj);
            }
        }
        return buf.toString();
}

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

 public static String join(Iterator iterator,
    String separator) 
{
        // handle null, zero and one elements before building a buffer
        if (iterator == null) {
            return null;
        }
        if (!iterator.hasNext()) {
            return EMPTY;
        }
        Object first = iterator.next();
        if (!iterator.hasNext()) {
            return ObjectUtils.toString(first);
        }
        // two or more elements
        StringBuffer buf = new StringBuffer(256); // Java default is 16, probably too small
        if (first != null) {
            buf.append(first);
        }
        while (iterator.hasNext()) {
            if (separator != null) {
                buf.append(separator);
            }
            Object obj = iterator.next();
            if (obj != null) {
                buf.append(obj);
            }
        }
        return buf.toString();
}

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

 public static String join(Collection collection,
    char separator) 
{
        if (collection == null) {
            return null;
        }
        return join(collection.iterator(), separator);
}

Joins the elements of the provided Collection 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) .

 public static String join(Collection collection,
    String separator) 
{
        if (collection == null) {
            return null;
        }
        return join(collection.iterator(), separator);
}

Joins the elements of the provided Collection 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) .

 public static String join(Object[] array,
    char separator,
    int startIndex,
    int endIndex) 
{
        if (array == null) {
            return null;
        }
        int bufSize = (endIndex - startIndex);
        if (bufSize < = 0) {
            return EMPTY;
        }
        bufSize *= ((array[startIndex] == null ? 16 : array[startIndex].toString().length()) + 1);
        StringBuffer buf = new StringBuffer(bufSize);
        for (int i = startIndex; i <  endIndex; i++) {
            if (i  > startIndex) {
                buf.append(separator);
            }
            if (array[i] != null) {
                buf.append(array[i]);
            }
        }
        return buf.toString();
}

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"

 public static String join(Object[] array,
    String separator,
    int startIndex,
    int endIndex) 
{
        if (array == null) {
            return null;
        }
        if (separator == null) {
            separator = EMPTY;
        }
        // endIndex - startIndex  > 0:   Len = NofStrings *(len(firstString) + len(separator))
        //           (Assuming that all Strings are roughly equally long)
        int bufSize = (endIndex - startIndex);
        if (bufSize < = 0) {
            return EMPTY;
        }
        bufSize *= ((array[startIndex] == null ? 16 : array[startIndex].toString().length())
                        + separator.length());
        StringBuffer buf = new StringBuffer(bufSize);
        for (int i = startIndex; i <  endIndex; i++) {
            if (i  > startIndex) {
                buf.append(separator);
            }
            if (array[i] != null) {
                buf.append(array[i]);
            }
        }
        return buf.toString();
}

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"

 public static int lastIndexOf(String str,
    char searchChar) 
{
        if (isEmpty(str)) {
            return -1;
        }
        return str.lastIndexOf(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

 public static int lastIndexOf(String str,
    String searchStr) 
{
        if (str == null || searchStr == null) {
            return -1;
        }
        return str.lastIndexOf(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

 public static int lastIndexOf(String str,
    char searchChar,
    int startPos) 
{
        if (isEmpty(str)) {
            return -1;
        }
        return str.lastIndexOf(searchChar, 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

 public static int lastIndexOf(String str,
    String searchStr,
    int startPos) 
{
        if (str == null || searchStr == null) {
            return -1;
        }
        return str.lastIndexOf(searchStr, 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

 public static int lastIndexOfAny(String str,
    String[] searchStrs) 
{
        if ((str == null) || (searchStrs == null)) {
            return -1;
        }
        int sz = searchStrs.length;
        int ret = -1;
        int tmp = 0;
        for (int i = 0; i <  sz; i++) {
            String search = searchStrs[i];
            if (search == null) {
                continue;
            }
            tmp = str.lastIndexOf(search);
            if (tmp  > ret) {
                ret = tmp;
            }
        }
        return ret;
}

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

 public static int lastIndexOfIgnoreCase(String str,
    String searchStr) 
{
        if (str == null || searchStr == null) {
            return -1;
        }
        return lastIndexOfIgnoreCase(str, searchStr, str.length());
}

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

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.lastIndexOfIgnoreCase(null, *)          = -1
StringUtils.lastIndexOfIgnoreCase(*, null)          = -1
StringUtils.lastIndexOfIgnoreCase("aabaabaa", "A")  = 7
StringUtils.lastIndexOfIgnoreCase("aabaabaa", "B")  = 5
StringUtils.lastIndexOfIgnoreCase("aabaabaa", "AB") = 4

 public static int lastIndexOfIgnoreCase(String str,
    String searchStr,
    int startPos) 
{
        if (str == null || searchStr == null) {
            return -1;
        }
        if (startPos  > (str.length() - searchStr.length())) {
            startPos = str.length() - searchStr.length();
        }
        if (startPos <  0) {
            return -1;
        }
        if (searchStr.length() == 0) {
            return startPos;
        }
        for (int i = startPos; i  >= 0; i--) {
            if (str.regionMatches(true, i, searchStr, 0, searchStr.length())) {
                return i;
            }
        }
        return -1;
}

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

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

 public static int lastOrdinalIndexOf(String str,
    String searchStr,
    int ordinal) 
{
        return ordinalIndexOf(str, searchStr, ordinal, true);
}

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(String str, int n)' may be implemented as:

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

 public static String left(String str,
    int len) 
{
        if (str == null) {
            return null;
        }
        if (len <  0) {
            return EMPTY;
        }
        if (str.length() < = len) {
            return str;
        }
        return str.substring(0, 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"

 public static String leftPad(String str,
    int size) 
{
        return leftPad(str, size, ' ');
}

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"

 public static String leftPad(String str,
    int size,
    char padChar) 
{
        if (str == null) {
            return null;
        }
        int pads = size - str.length();
        if (pads < = 0) {
            return str; // returns original String when possible
        }
        if (pads  > PAD_LIMIT) {
            return leftPad(str, size, String.valueOf(padChar));
        }
        return padding(pads, padChar).concat(str);
}

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"

 public static String leftPad(String str,
    int size,
    String padStr) 
{
        if (str == null) {
            return null;
        }
        if (isEmpty(padStr)) {
            padStr = " ";
        }
        int padLen = padStr.length();
        int strLen = str.length();
        int pads = size - strLen;
        if (pads < = 0) {
            return str; // returns original String when possible
        }
        if (padLen == 1 && pads < = PAD_LIMIT) {
            return leftPad(str, size, padStr.charAt(0));
        }
        if (pads == padLen) {
            return padStr.concat(str);
        } else if (pads <  padLen) {
            return padStr.substring(0, pads).concat(str);
        } else {
            char[] padding = new char[pads];
            char[] padChars = padStr.toCharArray();
            for (int i = 0; i <  pads; i++) {
                padding[i] = padChars[i % padLen];
            }
            return new String(padding).concat(str);
        }
}

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"

 public static int length(String str) 
{
        return str == null ? 0 : str.length();
}

Gets a String's length or 0 if the String is null.

 public static String lowerCase(String str) 
{
        if (str == null) {
            return null;
        }
        return str.toLowerCase();
}

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

 public static String lowerCase(String str,
    Locale locale) 
{
        if (str == null) {
            return null;
        }
        return str.toLowerCase(locale);
}

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"

 public static String mid(String str,
    int pos,
    int len) 
{
        if (str == null) {
            return null;
        }
        if (len <  0 || pos  > str.length()) {
            return EMPTY;
        }
        if (pos <  0) {
            pos = 0;
        }
        if (str.length() < = (pos + len)) {
            return str.substring(pos);
        }
        return str.substring(pos, pos + 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"

 public static int ordinalIndexOf(String str,
    String searchStr,
    int ordinal) 
{
        return ordinalIndexOf(str, searchStr, ordinal, false);
}

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

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

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

 public static String overlay(String str,
    String overlay,
    int start,
    int end) 
{
        if (str == null) {
            return null;
        }
        if (overlay == null) {
            overlay = EMPTY;
        }
        int len = str.length();
        if (start <  0) {
            start = 0;
        }
        if (start  > len) {
            start = len;
        }
        if (end <  0) {
            end = 0;
        }
        if (end  > len) {
            end = len;
        }
        if (start  > end) {
            int temp = start;
            start = end;
            end = temp;
        }
        return new StringBuffer(len + start - end + overlay.length() + 1)
            .append(str.substring(0, start))
            .append(overlay)
            .append(str.substring(end))
            .toString();
}

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"

 public static String overlayString(String text,
    String overlay,
    int start,
    int end) 
{
        return new StringBuffer(start + overlay.length() + text.length() - end + 1)
            .append(text.substring(0, start))
            .append(overlay)
            .append(text.substring(end))
            .toString();
}

Overlays part of a String with another String.

StringUtils.overlayString(null, *, *, *)           = NullPointerException
StringUtils.overlayString(*, null, *, *)           = NullPointerException
StringUtils.overlayString("", "abc", 0, 0)         = "abc"
StringUtils.overlayString("abcdef", null, 2, 4)    = "abef"
StringUtils.overlayString("abcdef", "", 2, 4)      = "abef"
StringUtils.overlayString("abcdef", "zzzz", 2, 4)  = "abzzzzef"
StringUtils.overlayString("abcdef", "zzzz", 4, 2)  = "abcdzzzzcdef"
StringUtils.overlayString("abcdef", "zzzz", -1, 4) = IndexOutOfBoundsException
StringUtils.overlayString("abcdef", "zzzz", 2, 8)  = IndexOutOfBoundsException

 public static String prechomp(String str,
    String sep) 
{
        int idx = str.indexOf(sep);
        if (idx == -1) {
            return str;
        }             
        return str.substring(idx + sep.length());
}

Remove the first value of a supplied String, and everything before it from a String.

 public static String remove(String str,
    String remove) 
{
        if (isEmpty(str) || isEmpty(remove)) {
            return str;
        }
        return replace(str, remove, EMPTY, -1);
}

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"

 public static String remove(String str,
    char remove) 
{
        if (isEmpty(str) || str.indexOf(remove) == -1) {
            return str;
        }
        char[] chars = str.toCharArray();
        int pos = 0;
        for (int i = 0; i <  chars.length; i++) {
            if (chars[i] != remove) {
                chars[pos++] = chars[i];
            }
        }
        return new String(chars, 0, pos);
}

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"

 public static String removeEnd(String str,
    String remove) 
{
        if (isEmpty(str) || isEmpty(remove)) {
            return str;
        }
        if (str.endsWith(remove)) {
            return str.substring(0, str.length() - remove.length());
        }
        return str;
}

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"

 public static String removeEndIgnoreCase(String str,
    String remove) 
{
        if (isEmpty(str) || isEmpty(remove)) {
            return str;
        }
        if (endsWithIgnoreCase(str, remove)) {
            return str.substring(0, str.length() - remove.length());
        }
        return str;
}

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

 public static String removeStart(String str,
    String remove) 
{
        if (isEmpty(str) || isEmpty(remove)) {
            return str;
        }
        if (str.startsWith(remove)){
            return str.substring(remove.length());
        }
        return str;
}

Removes a substring only if it is at the begining 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"

 public static String removeStartIgnoreCase(String str,
    String remove) 
{
        if (isEmpty(str) || isEmpty(remove)) {
            return str;
        }
        if (startsWithIgnoreCase(str, remove)) {
            return str.substring(remove.length());
        }
        return str;
}

Case insensitive removal of a substring if it is at the begining 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"

 public static String repeat(String str,
    int repeat) 
{
        // Performance tuned for 2.0 (JDK1.4)
        if (str == null) {
            return null;
        }
        if (repeat < = 0) {
            return EMPTY;
        }
        int inputLength = str.length();
        if (repeat == 1 || inputLength == 0) {
            return str;
        }
        if (inputLength == 1 && repeat < = PAD_LIMIT) {
            return padding(repeat, str.charAt(0));
        }
        int outputLength = inputLength * repeat;
        switch (inputLength) {
            case 1 :
                char ch = str.charAt(0);
                char[] output1 = new char[outputLength];
                for (int i = repeat - 1; i  >= 0; i--) {
                    output1[i] = ch;
                }
                return new String(output1);
            case 2 :
                char ch0 = str.charAt(0);
                char ch1 = str.charAt(1);
                char[] output2 = new char[outputLength];
                for (int i = repeat * 2 - 2; i  >= 0; i--, i--) {
                    output2[i] = ch0;
                    output2[i + 1] = ch1;
                }
                return new String(output2);
            default :
                StringBuffer buf = new StringBuffer(outputLength);
                for (int i = 0; i <  repeat; i++) {
                    buf.append(str);
                }
                return buf.toString();
        }
}

Repeat 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) = ""

 public static String repeat(String str,
    String separator,
    int repeat) 
{
        if(str == null || separator == null) {
            return repeat(str, repeat);
        } else {
            // given that repeat(String, int) is quite optimized, better to rely on it than try and splice this into it
            String result = repeat(str + separator, repeat);
            return removeEnd(result, separator);
        }
}

Repeat 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)    = "xxx"
StringUtils.repeat("?", ", ", 3)  = "?, ?, ?"

 public static String replace(String text,
    String searchString,
    String replacement) 
{
        return replace(text, searchString, replacement, -1);
}

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"

 public static String replace(String text,
    String searchString,
    String replacement,
    int max) 
{
        if (isEmpty(text) || isEmpty(searchString) || replacement == null || max == 0) {
            return text;
        }
        int start = 0;
        int end = text.indexOf(searchString, start);
        if (end == -1) {
            return text;
        }
        int replLength = searchString.length();
        int increase = replacement.length() - replLength;
        increase = (increase <  0 ? 0 : increase);
        increase *= (max <  0 ? 16 : (max  > 64 ? 64 : max));
        StringBuffer buf = new StringBuffer(text.length() + increase);
        while (end != -1) {
            buf.append(text.substring(start, end)).append(replacement);
            start = end + replLength;
            if (--max == 0) {
                break;
            }
            end = text.indexOf(searchString, start);
        }
        buf.append(text.substring(start));
        return buf.toString();
}

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"

 public static String replaceChars(String str,
    char searchChar,
    char replaceChar) 
{
        if (str == null) {
            return null;
        }
        return str.replace(searchChar, replaceChar);
}

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"

 public static String replaceChars(String str,
    String searchChars,
    String replaceChars) 
{
        if (isEmpty(str) || isEmpty(searchChars)) {
            return str;
        }
        if (replaceChars == null) {
            replaceChars = EMPTY;
        }
        boolean modified = false;
        int replaceCharsLength = replaceChars.length();
        int strLength = str.length();
        StringBuffer buf = new StringBuffer(strLength);
        for (int i = 0; i <  strLength; i++) {
            char ch = str.charAt(i);
            int index = searchChars.indexOf(ch);
            if (index  >= 0) {
                modified = true;
                if (index <  replaceCharsLength) {
                    buf.append(replaceChars.charAt(index));
                }
            } else {
                buf.append(ch);
            }
        }
        if (modified) {
            return buf.toString();
        }
        return str;
}

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"

 public static String replaceEach(String text,
    String[] searchList,
    String[] replacementList) 
{
        return replaceEach(text, searchList, replacementList, false, 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. 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"

 public static String replaceEachRepeatedly(String text,
    String[] searchList,
    String[] replacementList) 
{
        // timeToLive should be 0 if not used or nothing to replace, else it's
        // the length of the replace array
        int timeToLive = searchList == null ? 0 : searchList.length;
        return replaceEach(text, searchList, replacementList, true, timeToLive);
}

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 repeats)
 StringUtils.replaceEach("abcde", new String[]{"ab", "d"}, new String[]{"d", "t"}, false) = "dcte"
 StringUtils.replaceEach("abcde", new String[]{"ab", "d"}, new String[]{"d", "t"}, true) = "tcte"
 StringUtils.replaceEach("abcde", new String[]{"ab", "d"}, new String[]{"d", "ab"}, true) = IllegalArgumentException
 StringUtils.replaceEach("abcde", new String[]{"ab", "d"}, new String[]{"d", "ab"}, false) = "dcabe"

 public static String replaceOnce(String text,
    String searchString,
    String replacement) 
{
        return replace(text, searchString, replacement, 1);
}

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"

 public static String reverse(String str) 
{
        if (str == null) {
            return null;
        }
        return new StringBuffer(str).reverse().toString();
}

Reverses a String as per StringBuffer#reverse() .

A null String returns null.

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

 public static String reverseDelimited(String str,
    char separatorChar) 
{
        if (str == null) {
            return null;
        }
        // could implement manually, but simple way is to reuse other,
        // probably slower, methods.
        String[] strs = split(str, separatorChar);
        ArrayUtils.reverse(strs);
        return join(strs, separatorChar);
}

Reverses a String that is delimited by a specific character.

The Strings between the delimiters are not reversed. Thus java.lang.String becomes String.lang.java (if the 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"

 public static String reverseDelimitedString(String str,
    String separatorChars) 
{
        if (str == null) {
            return null;
        }
        // could implement manually, but simple way is to reuse other,
        // probably slower, methods.
        String[] strs = split(str, separatorChars);
        ArrayUtils.reverse(strs);
        if (separatorChars == null) {
            return join(strs, ' ');
        }
        return join(strs, separatorChars);
}

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.reverseDelimitedString(null, *)       = null
StringUtils.reverseDelimitedString("",*)          = ""
StringUtils.reverseDelimitedString("a.b.c", null) = "a.b.c"
StringUtils.reverseDelimitedString("a.b.c", ".")  = "c.b.a"

 public static String right(String str,
    int len) 
{
        if (str == null) {
            return null;
        }
        if (len <  0) {
            return EMPTY;
        }
        if (str.length() < = len) {
            return str;
        }
        return str.substring(str.length() - 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"

 public static String rightPad(String str,
    int size) 
{
        return rightPad(str, size, ' ');
}

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"

 public static String rightPad(String str,
    int size,
    char padChar) 
{
        if (str == null) {
            return null;
        }
        int pads = size - str.length();
        if (pads < = 0) {
            return str; // returns original String when possible
        }
        if (pads  > PAD_LIMIT) {
            return rightPad(str, size, String.valueOf(padChar));
        }
        return str.concat(padding(pads, padChar));
}

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"

 public static String rightPad(String str,
    int size,
    String padStr) 
{
        if (str == null) {
            return null;
        }
        if (isEmpty(padStr)) {
            padStr = " ";
        }
        int padLen = padStr.length();
        int strLen = str.length();
        int pads = size - strLen;
        if (pads < = 0) {
            return str; // returns original String when possible
        }
        if (padLen == 1 && pads < = PAD_LIMIT) {
            return rightPad(str, size, padStr.charAt(0));
        }
        if (pads == padLen) {
            return str.concat(padStr);
        } else if (pads <  padLen) {
            return str.concat(padStr.substring(0, pads));
        } else {
            char[] padding = new char[pads];
            char[] padChars = padStr.toCharArray();
            for (int i = 0; i <  pads; i++) {
                padding[i] = padChars[i % padLen];
            }
            return str.concat(new String(padding));
        }
}

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  "

 public static String[] split(String str) 
{
        return split(str, null, -1);
}

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

 public static String[] split(String str,
    char separatorChar) 
{
        return splitWorker(str, separatorChar, false);
}

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

 public static String[] split(String str,
    String separatorChars) 
{
        return splitWorker(str, separatorChars, -1, false);
}

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

 public static String[] split(String str,
    String separatorChars,
    int max) 
{
        return splitWorker(str, separatorChars, max, false);
}

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

 public static String[] splitByCharacterType(String str) 
{
        return splitByCharacterType(str, false);
}

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

 public static String[] splitByCharacterTypeCamelCase(String str) 
{
        return splitByCharacterType(str, true);
}

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

 public static String[] splitByWholeSeparator(String str,
    String separator) 
{
        return splitByWholeSeparatorWorker( str, separator, -1, false ) ;
}

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

 public static String[] splitByWholeSeparator(String str,
    String separator,
    int max) 
{
        return splitByWholeSeparatorWorker(str, separator, max, false);
}

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

 public static String[] splitByWholeSeparatorPreserveAllTokens(String str,
    String separator) 
{
        return splitByWholeSeparatorWorker(str, separator, -1, true);
}

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

 public static String[] splitByWholeSeparatorPreserveAllTokens(String str,
    String separator,
    int max) 
{
        return splitByWholeSeparatorWorker(str, separator, max, true);
}

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

 public static String[] splitPreserveAllTokens(String str) 
{
        return splitWorker(str, null, -1, true);
}

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

 public static String[] splitPreserveAllTokens(String str,
    char separatorChar) 
{
        return splitWorker(str, separatorChar, true);
}

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

 public static String[] splitPreserveAllTokens(String str,
    String separatorChars) 
{
        return splitWorker(str, separatorChars, -1, true);
}

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

 public static String[] splitPreserveAllTokens(String str,
    String separatorChars,
    int max) 
{
        return splitWorker(str, separatorChars, max, true);
}

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

 public static boolean startsWith(String str,
    String prefix) 
{
        return startsWith(str, prefix, false);
}

Check if a String 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

 public static boolean startsWithAny(String string,
    String[] searchStrings) 
{
        if (isEmpty(string) || ArrayUtils.isEmpty(searchStrings)) {
            return false;
        }
        for (int i = 0; i <  searchStrings.length; i++) {
            String searchString = searchStrings[i];
            if (StringUtils.startsWith(string, searchString)) {
                return true;
            }
        }
        return false;
}

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

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

 public static boolean startsWithIgnoreCase(String str,
    String prefix) 
{
        return startsWith(str, prefix, true);
}

Case insensitive check if a String 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

 public static String strip(String str) 
{
        return strip(str, 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"

 public static String strip(String str,
    String stripChars) 
{
        if (isEmpty(str)) {
            return str;
        }
        str = stripStart(str, stripChars);
        return stripEnd(str, 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"

 public static String[] stripAll(String[] strs) 
{
        return stripAll(strs, null);
}

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]

 public static String[] stripAll(String[] strs,
    String stripChars) 
{
        int strsLen;
        if (strs == null || (strsLen = strs.length) == 0) {
            return strs;
        }
        String[] newArr = new String[strsLen];
        for (int i = 0; i <  strsLen; i++) {
            newArr[i] = strip(strs[i], stripChars);
        }
        return newArr;
}

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]

 public static String stripEnd(String str,
    String stripChars) 
{
        int end;
        if (str == null || (end = str.length()) == 0) {
            return str;
        }
        if (stripChars == null) {
            while ((end != 0) && Character.isWhitespace(str.charAt(end - 1))) {
                end--;
            }
        } else if (stripChars.length() == 0) {
            return str;
        } else {
            while ((end != 0) && (stripChars.indexOf(str.charAt(end - 1)) != -1)) {
                end--;
            }
        }
        return str.substring(0, end);
}

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"

 public static String stripStart(String str,
    String stripChars) 
{
        int strLen;
        if (str == null || (strLen = str.length()) == 0) {
            return str;
        }
        int start = 0;
        if (stripChars == null) {
            while ((start != strLen) && Character.isWhitespace(str.charAt(start))) {
                start++;
            }
        } else if (stripChars.length() == 0) {
            return str;
        } else {
            while ((start != strLen) && (stripChars.indexOf(str.charAt(start)) != -1)) {
                start++;
            }
        }
        return str.substring(start);
}

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  "

 public static String stripToEmpty(String str) 
{
        return str == null ? EMPTY : strip(str, null);
}

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"

 public static String stripToNull(String str) 
{
        if (str == null) {
            return null;
        }
        str = strip(str, null);
        return str.length() == 0 ? null : 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"

 public static String substring(String str,
    int start) 
{
        if (str == null) {
            return null;
        }
        // handle negatives, which means last n characters
        if (start <  0) {
            start = str.length() + start; // remember start is negative
        }
        if (start <  0) {
            start = 0;
        }
        if (start  > str.length()) {
            return EMPTY;
        }
        return str.substring(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"

 public static String substring(String str,
    int start,
    int end) 
{
        if (str == null) {
            return null;
        }
        // handle negatives
        if (end <  0) {
            end = str.length() + end; // remember end is negative
        }
        if (start <  0) {
            start = str.length() + start; // remember start is negative
        }
        // check length next
        if (end  > str.length()) {
            end = str.length();
        }
        // if start is greater than end, return ""
        if (start  > end) {
            return EMPTY;
        }
        if (start <  0) {
            start = 0;
        }
        if (end <  0) {
            end = 0;
        }
        return str.substring(start, 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"

 public static String substringAfter(String str,
    String separator) 
{
        if (isEmpty(str)) {
            return str;
        }
        if (separator == null) {
            return EMPTY;
        }
        int pos = str.indexOf(separator);
        if (pos == -1) {
            return EMPTY;
        }
        return str.substring(pos + separator.length());
}

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"

 public static String substringAfterLast(String str,
    String separator) 
{
        if (isEmpty(str)) {
            return str;
        }
        if (isEmpty(separator)) {
            return EMPTY;
        }
        int pos = str.lastIndexOf(separator);
        if (pos == -1 || pos == (str.length() - separator.length())) {
            return EMPTY;
        }
        return str.substring(pos + separator.length());
}

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")     = ""

 public static String substringBefore(String str,
    String separator) 
{
        if (isEmpty(str) || separator == null) {
            return str;
        }
        if (separator.length() == 0) {
            return EMPTY;
        }
        int pos = str.indexOf(separator);
        if (pos == -1) {
            return str;
        }
        return str.substring(0, pos);
}

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"

 public static String substringBeforeLast(String str,
    String separator) 
{
        if (isEmpty(str) || isEmpty(separator)) {
            return str;
        }
        int pos = str.lastIndexOf(separator);
        if (pos == -1) {
            return str;
        }
        return str.substring(0, pos);
}

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"

 public static String substringBetween(String str,
    String tag) 
{
        return substringBetween(str, tag, 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"

 public static String substringBetween(String str,
    String open,
    String close) 
{
        if (str == null || open == null || close == null) {
            return null;
        }
        int start = str.indexOf(open);
        if (start != -1) {
            int end = str.indexOf(close, start + open.length());
            if (end != -1) {
                return str.substring(start + open.length(), end);
            }
        }
        return null;
}

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

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

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"

 public static String[] substringsBetween(String str,
    String open,
    String close) 
{
        if (str == null || isEmpty(open) || isEmpty(close)) {
            return null;
        }
        int strLen = str.length();
        if (strLen == 0) {
            return ArrayUtils.EMPTY_STRING_ARRAY;
        }
        int closeLen = close.length();
        int openLen = open.length();
        List list = new ArrayList();
        int pos = 0;
        while (pos <  (strLen - closeLen)) {
            int start = str.indexOf(open, pos);
            if (start <  0) {
                break;
            }
            start += openLen;
            int end = str.indexOf(close, start);
            if (end <  0) {
                break;
            }
            list.add(str.substring(start, end));
            pos = end + closeLen;
        }
        if (list.isEmpty()) {
            return null;
        } 
        return (String[]) list.toArray(new String [list.size()]);
}

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

 public static String swapCase(String str) 
{
        int strLen;
        if (str == null || (strLen = str.length()) == 0) {
            return str;
        }
        StringBuffer buffer = new StringBuffer(strLen);
        char ch = 0;
        for (int i = 0; i <  strLen; i++) {
            ch = str.charAt(i);
            if (Character.isUpperCase(ch)) {
                ch = Character.toLowerCase(ch);
            } else if (Character.isTitleCase(ch)) {
                ch = Character.toLowerCase(ch);
            } else if (Character.isLowerCase(ch)) {
                ch = Character.toUpperCase(ch);
            }
            buffer.append(ch);
        }
        return buffer.toString();
}

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

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

For a word based algorithm, see 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 WordUtils.

 public static String trim(String str) 
{
        return str == null ? null : str.trim();
}

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"

 public static String trimToEmpty(String str) 
{
        return str == null ? EMPTY : str.trim();
}

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"

 public static String trimToNull(String str) 
{
        String ts = trim(str);
        return isEmpty(ts) ? null : ts;
}

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"

 public static String uncapitalise(String str) 
{
        return uncapitalize(str);
}

Uncapitalizes a String changing the first letter to title case as per Character#toLowerCase(char) . No other letters are changed.

 public static String uncapitalize(String str) 
{
        int strLen;
        if (str == null || (strLen = str.length()) == 0) {
            return str;
        }
        return new StringBuffer(strLen)
            .append(Character.toLowerCase(str.charAt(0)))
            .append(str.substring(1))
            .toString();
}

Uncapitalizes a String changing the first letter to title case as per Character#toLowerCase(char) . No other letters 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"

 public static String upperCase(String str) 
{
        if (str == null) {
            return null;
        }
        return str.toUpperCase();
}

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 #lowerCase(String, Locale) should be used with a specific locale (e.g. Locale#ENGLISH ).

 public static String upperCase(String str,
    Locale locale) 
{
        if (str == null) {
            return null;
        }
        return str.toUpperCase(locale);
}

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"