StringUtils (Maven Shared Utils 0.4 API)

java.lang.Object
- org.apache.maven.shared.utils.StringUtils

```
public class StringUtils
extends Object
```
Common String manipulation routines.

Originally from Turbine, the GenerationJavaCore library and Velocity. Later a lots methods from commons-lang StringUtils got added too. Gradually smaller additions and fixes have been made over the time by various ASF committers.

Version:

$Id: StringUtils.java 1402496 2012-10-26 13:00:39Z rfscholte $

Author:

Jon S. Stevens, Daniel Rall, Greg Coladonato, Henri Yandell, Ed Korthof, Rand McNeely, Stephen Colebourne, Fredrik Westermarck, Holger Krauth, Alexander Day Chaffee

Constructor Summary

Constructors
Constructor and Description

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

Constructors
Constructor and Description
`StringUtils()` `StringUtils` instances should NOT be constructed in standard programming.

Method Summary

Methods
Modifier and Type	Method and Description
`static String`	`abbreviate(String s, int maxWidth)` Turn "Now is the time for all good men" into "Now is the time for..." Specifically: If str is less than max characters long, return it.
`static String`	`abbreviate(String s, int offset, int maxWidth)` 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.
`static String`	`addAndDeHump(String view)` Take the input string and un-camel-case it.
`static String`	`capitalise(String str)` Capitalise a String.
`static String`	`capitaliseAllWords(String str)` Capitalise all the words in a String.
`static String`	`capitalizeFirstLetter(String data)` Convert the first character of the given String to uppercase.
`static String`	`center(String str, int size)` Center a String in a larger String of size `n`.
`static String`	`center(String str, int size, String delim)` Center a String in a larger String of size `n`.
`static String`	`chomp(String str)` Remove the last newline, and everything after it from a String.
`static String`	`chomp(String str, String sep)` Remove the last value of a supplied String, and everything after it from a String.
`static String`	`chompLast(String str)` Remove a newline if and only if it is at the end of the supplied String.
`static String`	`chompLast(String str, String sep)` Remove a value if and only if the String ends with that value.
`static String`	`chop(String str)` Remove the last character from a String.
`static String`	`chopNewline(String str)` Remove `\n` from end of a String if it's there.
`static String`	`clean(String str)` Removes control characters, including whitespace, from both ends of this String, handling `null` by returning an empty String.
`static String`	`concatenate(Object... array)` Concatenates elements of an array into a single String.
`static boolean`	`contains(String str, char searchChar)` Checks if String contains a search character, handling `null`.
`static boolean`	`contains(String str, String searchStr)` Checks if String contains a search String, handling `null`.
`static int`	`countMatches(String str, String sub)` How many times is the substring in the larger String.
`static String`	`defaultString(Object obj)` Returns either the passed in `Object` as a String, or, if the `Object` is `null`, an empty String.
`static String`	`defaultString(Object obj, String defaultString)` Returns either the passed in `Object` as a String, or, if the `Object` is `null`, a passed in default String.
`static String`	`deleteWhitespace(String str)` Deletes all whitespaces from a String.
`static String`	`difference(String s1, String s2)` Compare two strings, and return the portion where they differ.
`static int`	`differenceAt(String s1, String s2)` Compare two strings, and return the index at which the strings begin to differ.
`static boolean`	`equals(String str1, String str2)` Compares two Strings, returning `true` if they are equal.
`static boolean`	`equalsIgnoreCase(String str1, String str2)` Compares two Strings, returning `true` if they are equal ignoring the case.
`static String`	`escape(String str)` Escapes any values it finds into their String form.
`static String`	`escape(String source, char[] escapedChars, char escapeChar)`
`static String`	`getChomp(String str, String sep)` Remove everything and return the last value of a supplied String, and everything after it from a String.
`static String`	`getNestedString(String str, String tag)` Get the String that is nested in between two instances of the same String.
`static String`	`getNestedString(String str, String open, String close)` Get the String that is nested in between two Strings.
`static String`	`getPrechomp(String str, String sep)` Remove and return everything before the first value of a supplied String from another String.
`static int`	`indexOfAny(String str, String... searchStrs)` Find the first index of any of a set of potential substrings.
`static String`	`interpolate(String text, Map<?,?> namespace)` Fill all 'variables' in the given text with the values from the map.
`static boolean`	`isAlpha(String str)` Checks if the String contains only unicode letters.
`static boolean`	`isAlphanumeric(String str)` Checks if the String contains only unicode letters or digits.
`static boolean`	`isAlphanumericSpace(String str)` Checks if the String contains only unicode letters, digits or space (`' '`).
`static boolean`	`isAlphaSpace(String str)` Checks if the String contains only unicode letters and space (`' '`).
`static boolean`	`isBlank(String str)` Checks if a String is whitespace, empty ("") or null.
`static boolean`	`isEmpty(String str)` Checks if a (trimmed) String is `null` or empty.
`static boolean`	`isNotBlank(String str)` Checks if a String is not empty (""), not null and not whitespace only.
`static boolean`	`isNotEmpty(String str)` Checks if a String is non `null` and is not empty (`length > 0`).
`static boolean`	`isNumeric(String str)` Checks if the String contains only unicode digits.
`static boolean`	`isWhitespace(String str)` Checks if the String contains only whitespace.
`static String`	`join(Iterator<?> iterator, String separator)` Joins the elements of the provided `Iterator` into a single String containing the provided elements.
`static String`	`join(Object[] array, String separator)` Joins the elements of the provided array into a single String containing the provided list of elements.
`static int`	`lastIndexOfAny(String str, String... searchStrs)` Find the latest index of any of a set of potential substrings.
`static String`	`left(String str, int len)` Gets the leftmost `n` characters of a String.
`static String`	`leftPad(String str, int size)` Left pad a String with spaces.
`static String`	`leftPad(String str, int size, String delim)` Left pad a String with a specified string.
`static String`	`lowerCase(String str)` Convert a String to lower case, `null` String returns `null`.
`static String`	`lowercaseFirstLetter(String data)` Convert the first character of the given String to lowercase.
`static String`	`mid(String str, int pos, int len)` Gets `n` characters from the middle of a String.
`static String`	`overlayString(String text, String overlay, int start, int end)` Overlay a part of a String with another String.
`static String`	`prechomp(String str, String sep)` Remove the first value of a supplied String, and everything before it from a String.
`static String`	`quoteAndEscape(String source, char quoteChar)` Quote and escape a String with the given character, handling `null`.
`static String`	`quoteAndEscape(String source, char quoteChar, char[] quotingTriggers)` Quote and escape a String with the given character, handling `null`.
`static String`	`quoteAndEscape(String source, char quoteChar, char[] escapedChars, char[] quotingTriggers, char escapeChar, boolean force)`
`static String`	`quoteAndEscape(String source, char quoteChar, char[] escapedChars, char escapeChar, boolean force)`
`static String`	`removeAndHump(String data, String replaceThis)` This is basically the inverse of `addAndDeHump(String)`.
`static String`	`removeDuplicateWhitespace(String s)` Remove all duplicate whitespace characters and line terminators are replaced with a single space.
`static String`	`repeat(String str, int repeat)` Repeat a String `n` times to form a new string.
`static String`	`replace(String text, char repl, char with)` Replace all occurances of a char within another char.
`static String`	`replace(String text, char repl, char with, int max)` Replace a char with another char inside a larger String, for the first `max` values of the search char.
`static String`	`replace(String text, String repl, String with)` Replace all occurances of a String within another String.
`static String`	`replace(String text, String repl, String with, int max)` Replace a String with another String inside a larger String, for the first `max` values of the search String.
`static String`	`replaceOnce(String text, char repl, char with)` Replace a char with another char inside a larger String, once.
`static String`	`replaceOnce(String text, String repl, String with)` Replace a String with another String inside a larger String, once.
`static String`	`reverse(String str)` Reverse a String.
`static String`	`reverseDelimitedString(String str, String delimiter)` Reverses a String that is delimited by a specific character.
`static String`	`right(String str, int len)` Gets the rightmost `n` characters of a String.
`static String`	`rightPad(String str, int size)` Right pad a String with spaces.
`static String`	`rightPad(String str, int size, String delim)` Right pad a String with a specified string.
`static String[]`	`split(String str)` Splits the provided text into a array, using whitespace as the separator.
`static String[]`	`split(String text, String separator)`
`static String[]`	`split(String str, String separator, int max)` Splits the provided text into a array, based on a given separator.
`static String`	`strip(String str)` Remove whitespace from the front and back of a String.
`static String`	`strip(String str, String delim)` Remove a specified String from the front and back of a String.
`static String[]`	`stripAll(String... strs)` Strip whitespace from the front and back of every String in the array.
`static String[]`	`stripAll(String[] strs, String delimiter)` Strip the specified delimiter from the front and back of every String in the array.
`static String`	`stripEnd(String str, String strip)` Strip any of a supplied String from the end of a String.
`static String`	`stripStart(String str, String strip)` Strip any of a supplied String from the start of a String.
`static String`	`substring(String str, int start)` Gets a substring from the specified string avoiding exceptions.
`static String`	`substring(String str, int start, int end)` Gets a substring from the specified String avoiding exceptions.
`static String`	`swapCase(String str)` Swaps the case of String.
`static String`	`trim(String str)` Removes control characters, including whitespace, from both ends of this String, handling `null` by returning `null`.
`static String`	`uncapitalise(String str)` Uncapitalise a String.
`static String`	`uncapitaliseAllWords(String str)` Uncapitalise all the words in a string.
`static String`	`unifyLineSeparators(String s)` Parses the given String and replaces all occurrences of '\n', '\r' and '\r\n' with the system line separator.
`static String`	`unifyLineSeparators(String s, String ls)` Parses the given String and replaces all occurrences of '\n', '\r' and '\r\n' with the system line separator.
`static String`	`upperCase(String str)` Convert a String to upper case, `null` String returns `null`.

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

- Constructor Detail
  - StringUtils
```
public StringUtils()
```
    StringUtils instances should NOT be constructed in standard programming. Instead, the class should be used as StringUtils.trim(" foo ");.
    
    This constructor is public to permit tools that require a JavaBean manager to operate.
- Method Detail
  - clean
```
@Nonnull
public static String clean(String str)
```
    Removes control characters, including whitespace, from both ends of this String, handling null by returning an empty String.
    
    Parameters:
    str - the String to check
    
    Returns:
    the trimmed text (never null)
    See Also:
    String.trim()
  - trim
```
public static String trim(String str)
```
    Removes control characters, including whitespace, from both ends of this String, handling null by returning null.
    
    Parameters:
    str - the String to check
    
    Returns:
    the trimmed text (or null)
    See Also:
    String.trim()
  - deleteWhitespace
```
@Nonnull
public static String deleteWhitespace(@Nonnull
                              String str)
```
    Deletes all whitespaces from a String.
    
    Whitespace is defined by Character.isWhitespace(char).
    
    Parameters:
    str - String target to delete whitespace from
    
    Returns:
    the String without whitespaces
    
    Throws:
    
    NullPointerException
  - isNotEmpty
```
public static boolean isNotEmpty(String str)
```
    Checks if a String is non null and is not empty (length > 0).
    
    Parameters:
    str - the String to check
    
    Returns:
    true if the String is non-null, and not length zero
  - isEmpty
```
public static boolean isEmpty(@Nullable
              String str)
```
    Checks if a (trimmed) String is null or empty.
    
    Note: In future releases, this method will no longer trim the input string such that it works complementary to isNotEmpty(String). Code that wants to test for whitespace-only strings should be migrated to use isBlank(String) instead.
    
    Parameters:
    str - the String to check
    
    Returns:
    true if the String is null, or length zero once trimmed
  - isBlank
```
public static boolean isBlank(@Nullable
              String str)
```
    Checks if a String is whitespace, empty ("") or null.
```
 StringUtils.isBlank(null)      = true
 StringUtils.isBlank("")        = true
 StringUtils.isBlank(" ")       = true
 StringUtils.isBlank("bob")     = false
 StringUtils.isBlank("  bob  ") = false
 
```
    Parameters:
    str - the String to check, may be null
    
    Returns:
    true if the String is null, empty or whitespace
  - isNotBlank
```
public static boolean isNotBlank(@Nullable
                 String str)
```
    Checks if a String is not empty (""), not null and not whitespace only.
```
 StringUtils.isNotBlank(null)      = false
 StringUtils.isNotBlank("")        = false
 StringUtils.isNotBlank(" ")       = false
 StringUtils.isNotBlank("bob")     = true
 StringUtils.isNotBlank("  bob  ") = true
 
```
    Parameters:
    str - the String to check, may be null
    
    Returns:
    true if the String is not empty and not null and not whitespace
  - equals
```
public static boolean equals(@Nullable
             String str1,
             @Nullable
             String str2)
```
    Compares two Strings, returning true if they are equal.
    
    nulls are handled without exceptions. Two null references are considered to be equal. The comparison is case sensitive.
    
    Parameters:
    str1 - the first string
    str2 - the second string
    
    Returns:
    true if the Strings are equal, case sensitive, or both null
    See Also:
    String.equals(Object)
  - equalsIgnoreCase
```
public static boolean equalsIgnoreCase(String str1,
                       String str2)
```
    Compares two Strings, returning true if they are equal ignoring the case.
    
    Nulls are handled without exceptions. Two null references are considered equal. Comparison is case insensitive.
    
    Parameters:
    str1 - the first string
    str2 - the second string
    
    Returns:
    true if the Strings are equal, case insensitive, or both null
    See Also:
    String.equalsIgnoreCase(String)
  - indexOfAny
```
public static int indexOfAny(String str,
             String... searchStrs)
```
    Find the first index of any of a set of potential substrings.
    
    null String will return -1.
    
    Parameters:
    str - the String to check
    searchStrs - the Strings to search for
    
    Returns:
    the first index of any of the searchStrs in str
    
    Throws:
    
    NullPointerException - if any of searchStrs[i] is null
  - lastIndexOfAny
```
public static int lastIndexOfAny(String str,
                 String... searchStrs)
```
    Find the latest index of any of a set of potential substrings.
    
    null string will return -1.
    
    Parameters:
    str - the String to check
    searchStrs - the Strings to search for
    
    Returns:
    the last index of any of the Strings
    
    Throws:
    
    NullPointerException - if any of searchStrs[i] is null
  - substring
```
public static String substring(String str,
               int start)
```
    Gets a substring from the specified string avoiding exceptions.
    
    A negative start position can be used to start n characters from the end of the String.
    
    Parameters:
    str - the String to get the substring from
    start - the position to start from, negative means count back from the end of the String by this many characters
    
    Returns:
    substring from start position
  - substring
```
public static String substring(String str,
               int start,
               int end)
```
    Gets a substring from the specified String avoiding exceptions.
    
    A negative start position can be used to start/end n characters from the end of the String.
    
    Parameters:
    str - the String to get the substring from
    start - the position to start from, negative means count back from the end of the string by this many characters
    end - the position to end at (exclusive), negative means count back from the end of the String by this many characters
    
    Returns:
    substring from start position to end positon
  - left
```
public static String left(String str,
          int len)
```
    Gets the leftmost n characters of a String.
    
    If n characters are not available, or the String is null, the String will be returned without an exception.
    
    Parameters:
    str - the String to get the leftmost characters from
    len - the length of the required String
    
    Returns:
    the leftmost characters
    
    Throws:
    
    IllegalArgumentException - if len is less than zero
  - right
```
public static String right(String str,
           int len)
```
    Gets the rightmost n characters of a String.
    
    If n characters are not available, or the String is null, the String will be returned without an exception.
    
    Parameters:
    str - the String to get the rightmost characters from
    len - the length of the required String
    
    Returns:
    the leftmost characters
    
    Throws:
    
    IllegalArgumentException - if len is less than zero
  - mid
```
public static String mid(String str,
         int pos,
         int len)
```
    Gets n characters from the middle of a String.
    
    If n characters are not available, the remainder of the String will be returned without an exception. If the String is null, null will be returned.
    
    Parameters:
    str - the String to get the characters from
    pos - the position to start from
    len - the length of the required String
    
    Returns:
    the leftmost characters
    
    Throws:
    
    IndexOutOfBoundsException - if pos is out of bounds
    
    IllegalArgumentException - if len is less than zero
  - split
```
@Nonnull
public static String[] split(@Nonnull
                     String str)
```
    Splits the provided text into a array, using whitespace as the separator.
    
    The separator is not included in the returned String array.
    
    Parameters:
    str - the String to parse
    
    Returns:
    an array of parsed Strings
  - split
```
@Nonnull
public static String[] split(@Nonnull
                     String text,
                     String separator)
```
    See Also:
    split(String, String, int)
  - split
```
@Nonnull
public static String[] split(@Nonnull
                     String str,
                     String separator,
                     int max)
```
    Splits the provided text into a array, based on a given separator.
    
    The separator is not included in the returned String array. The maximum number of splits to perfom can be controlled. A null separator will cause parsing to be on whitespace.
    
    This is useful for quickly splitting a String directly into an array of tokens, instead of an enumeration of tokens (as StringTokenizer does).
    
    Parameters:
    str - The string to parse.
    separator - Characters used as the delimiters. If null, splits on whitespace.
    max - The maximum number of elements to include in the array. A zero or negative value implies no limit.
    
    Returns:
    an array of parsed Strings
  - concatenate
```
@Nonnull
public static String concatenate(@Nonnull
                         Object... array)
```
    Concatenates elements of an array into a single String.
    
    The difference from join is that concatenate has no delimiter.
    
    Parameters:
    array - the array of values to concatenate.
    
    Returns:
    the concatenated string.
  - join
```
@Nonnull
public static String join(@Nonnull
                  Object[] array,
                  String separator)
```
    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 a blank String.
    
    Parameters:
    array - the array of values to join together
    separator - the separator character to use
    
    Returns:
    the joined String
  - join
```
@Nonnull
public static String join(@Nonnull
                  Iterator<?> iterator,
                  String separator)
```
    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 a blank String.
    
    Parameters:
    iterator - the Iterator of values to join together
    separator - the separator character to use
    
    Returns:
    the joined String
  - replaceOnce
```
public static String replaceOnce(@Nullable
                 String text,
                 char repl,
                 char with)
```
    Replace a char with another char inside a larger String, once.
    
    A null reference passed to this method is a no-op.
    
    Parameters:
    text - text to search and replace in
    repl - char to search for
    with - char to replace with
    
    Returns:
    the text with any replacements processed
    See Also:
    replace(String text, char repl, char with, int max)
  - replace
```
public static String replace(@Nullable
             String text,
             char repl,
             char with)
```
    Replace all occurances of a char within another char.
    
    A null reference passed to this method is a no-op.
    
    Parameters:
    text - text to search and replace in
    repl - char to search for
    with - char to replace with
    
    Returns:
    the text with any replacements processed
    See Also:
    replace(String text, char repl, char with, int max)
  - replace
```
public static String replace(@Nullable
             String text,
             char repl,
             char with,
             int max)
```
    Replace a char with another char inside a larger String, for the first max values of the search char.
    
    A null reference passed to this method is a no-op.
    
    Parameters:
    text - text to search and replace in
    repl - char to search for
    with - char to replace with
    max - maximum number of values to replace, or -1 if no maximum
    
    Returns:
    the text with any replacements processed
  - replaceOnce
```
public static String replaceOnce(@Nullable
                 String text,
                 @Nullable
                 String repl,
                 @Nullable
                 String with)
```
    Replace a String with another String inside a larger String, once.
    
    A null reference passed to this method is a no-op.
    
    Parameters:
    text - text to search and replace in
    repl - String to search for
    with - String to replace with
    
    Returns:
    the text with any replacements processed
    See Also:
    replace(String text, String repl, String with, int max)
  - replace
```
public static String replace(@Nullable
             String text,
             @Nullable
             String repl,
             @Nullable
             String with)
```
    Replace all occurances of a String within another String.
    
    A null reference passed to this method is a no-op.
    
    Parameters:
    text - text to search and replace in
    repl - String to search for
    with - String to replace with
    
    Returns:
    the text with any replacements processed
    See Also:
    replace(String text, String repl, String with, int max)
  - replace
```
public static String replace(@Nullable
             String text,
             @Nullable
             String repl,
             @Nullable
             String with,
             int max)
```
    Replace 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.
    
    Parameters:
    text - text to search and replace in
    repl - String to search for
    with - String to replace with
    max - maximum number of values to replace, or -1 if no maximum
    
    Returns:
    the text with any replacements processed
  - overlayString
```
@Nonnull
public static String overlayString(@Nonnull
                           String text,
                           @Nonnull
                           String overlay,
                           int start,
                           int end)
```
    Overlay a part of a String with another String.
    
    Parameters:
    text - String to do overlaying in
    overlay - String to overlay
    start - int to start overlaying at
    end - int to stop overlaying before
    
    Returns:
    String with overlayed text
    
    Throws:
    
    NullPointerException - if text or overlay is null
  - center
```
@Nonnull
public static String center(@Nonnull
                    String str,
                    int size)
```
    Center a String in a larger String of size n.
    
    Uses spaces as the value to buffer the String with. Equivalent to center(str, size, " ").
    
    Parameters:
    str - String to center
    size - int size of new String
    
    Returns:
    String containing centered String
    
    Throws:
    
    NullPointerException - if str is null
  - center
```
@Nonnull
public static String center(@Nonnull
                    String str,
                    int size,
                    @Nonnull
                    String delim)
```
    Center a String in a larger String of size n.
    
    Uses a supplied String as the value to buffer the String with.
    
    Parameters:
    str - String to center
    size - int size of new String
    delim - String to buffer the new String with
    
    Returns:
    String containing centered String
    
    Throws:
    
    NullPointerException - if str or delim is null
    
    ArithmeticException - if delim is the empty String
  - chomp
```
@Nonnull
public static String chomp(@Nonnull
                   String str)
```
    Remove the last newline, and everything after it from a String.
    
    Parameters:
    str - String to chomp the newline from
    
    Returns:
    String without chomped newline
    
    Throws:
    
    NullPointerException - if str is null
  - chomp
```
@Nonnull
public static String chomp(@Nonnull
                   String str,
                   @Nonnull
                   String sep)
```
    Remove the last value of a supplied String, and everything after it from a String.
    
    Parameters:
    str - String to chomp from
    sep - String to chomp
    
    Returns:
    String without chomped ending
    
    Throws:
    
    NullPointerException - if str or sep is null
  - chompLast
```
@Nonnull
public static String chompLast(@Nonnull
                       String str)
```
    Remove a newline if and only if it is at the end of the supplied String.
    
    Parameters:
    str - String to chomp from
    
    Returns:
    String without chomped ending
    
    Throws:
    
    NullPointerException - if str is null
  - chompLast
```
@Nonnull
public static String chompLast(@Nonnull
                       String str,
                       @Nonnull
                       String sep)
```
    Remove a value if and only if the String ends with that value.
    
    Parameters:
    str - String to chomp from
    sep - String to chomp
    
    Returns:
    String without chomped ending
    
    Throws:
    
    NullPointerException - if str or sep is null
  - getChomp
```
@Nonnull
public static String getChomp(@Nonnull
                      String str,
                      @Nonnull
                      String sep)
```
    Remove everything and return the last value of a supplied String, and everything after it from a String.
    
    Parameters:
    str - String to chomp from
    sep - String to chomp
    
    Returns:
    String chomped
    
    Throws:
    
    NullPointerException - if str or sep is null
  - prechomp
```
@Nonnull
public static String prechomp(@Nonnull
                      String str,
                      @Nonnull
                      String sep)
```
    Remove the first value of a supplied String, and everything before it from a String.
    
    Parameters:
    str - String to chomp from
    sep - String to chomp
    
    Returns:
    String without chomped beginning
    
    Throws:
    
    NullPointerException - if str or sep is null
  - getPrechomp
```
@Nonnull
public static String getPrechomp(@Nonnull
                         String str,
                         String sep)
```
    Remove and return everything before the first value of a supplied String from another String.
    
    Parameters:
    str - String to chomp from
    sep - String to chomp
    
    Returns:
    String prechomped
    
    Throws:
    
    NullPointerException - if str or sep is null
  - chop
```
@Nonnull
public static String chop(@Nonnull
                  String str)
```
    Remove the last character from a String.
    
    If the String ends in \r\n, then remove both of them.
    
    Parameters:
    str - String to chop last character from
    
    Returns:
    String without last character
    
    Throws:
    
    NullPointerException - if str is null
  - chopNewline
```
@Nonnull
public static String chopNewline(@Nonnull
                         String str)
```
    Remove \n from end of a String if it's there. If a \r precedes it, then remove that too.
    
    Parameters:
    str - String to chop a newline from
    
    Returns:
    String without newline
    
    Throws:
    
    NullPointerException - if str is null
  - escape
```
@Nonnull
public static String escape(@Nonnull
                    String str)
```
    Escapes any values it finds into their String form.
    
    So a tab becomes the characters '\\' and 't'.
    
    Parameters:
    str - String to escape values in
    
    Returns:
    String with escaped values
    
    Throws:
    
    NullPointerException - if str is null
  - repeat
```
@Nonnull
public static String repeat(@Nonnull
                    String str,
                    int repeat)
```
    Repeat a String n times to form a new string.
    
    Parameters:
    str - String to repeat
    repeat - number of times to repeat str
    
    Returns:
    String with repeated String
    
    Throws:
    
    NegativeArraySizeException - if repeat < 0
    
    NullPointerException - if str is null
  - rightPad
```
@Nonnull
public static String rightPad(@Nonnull
                      String str,
                      int size)
```
    Right pad a String with spaces.
    
    The String is padded to the size of n.
    
    Parameters:
    str - String to repeat
    size - number of times to repeat str
    
    Returns:
    right padded String
    
    Throws:
    
    NullPointerException - if str is null
  - rightPad
```
@Nonnull
public static String rightPad(@Nonnull
                      String str,
                      int size,
                      @Nonnull
                      String delim)
```
    Right pad a String with a specified string.
    
    The String is padded to the size of n.
    
    Parameters:
    str - String to pad out
    size - size to pad to
    delim - String to pad with
    
    Returns:
    right padded String
    
    Throws:
    
    NullPointerException - if str or delim is null
    
    ArithmeticException - if delim is the empty String
  - leftPad
```
@Nonnull
public static String leftPad(@Nonnull
                     String str,
                     int size)
```
    Left pad a String with spaces.
    
    The String is padded to the size of n.
    
    Parameters:
    str - String to pad out
    size - size to pad to
    
    Returns:
    left padded String
    
    Throws:
    
    NullPointerException - if str or delim is null
  - leftPad
```
@Nonnull
public static String leftPad(@Nonnull
                     String str,
                     int size,
                     @Nonnull
                     String delim)
```
    Left pad a String with a specified string. Pad to a size of n.
    
    Parameters:
    str - String to pad out
    size - size to pad to
    delim - String to pad with
    
    Returns:
    left padded String
    
    Throws:
    
    NullPointerException - if str or delim is null
    
    ArithmeticException - if delim is the empty string
  - strip
```
public static String strip(String str)
```
    Remove whitespace from the front and back of a String.
    
    Parameters:
    str - the String to remove whitespace from
    
    Returns:
    the stripped String
  - strip
```
public static String strip(String str,
           @Nullable
           String delim)
```
    Remove a specified String from the front and back of a String.
    
    If whitespace is wanted to be removed, used the strip(java.lang.String) method.
    
    Parameters:
    str - the String to remove a string from
    delim - the String to remove at start and end
    
    Returns:
    the stripped String
  - stripAll
```
public static String[] stripAll(String... strs)
```
    Strip whitespace from the front and back of every String in the array.
    
    Parameters:
    strs - the Strings to remove whitespace from
    
    Returns:
    the stripped Strings
  - stripAll
```
public static String[] stripAll(String[] strs,
                @Nullable
                String delimiter)
```
    Strip the specified delimiter from the front and back of every String in the array.
    
    Parameters:
    strs - the Strings to remove a String from
    delimiter - the String to remove at start and end
    
    Returns:
    the stripped Strings
  - stripEnd
```
public static String stripEnd(String str,
              @Nullable
              String strip)
```
    Strip any of a supplied String from the end of a String.
    
    If the strip String is null, whitespace is stripped.
    
    Parameters:
    str - the String to remove characters from
    strip - the String to remove
    
    Returns:
    the stripped String
  - stripStart
```
public static String stripStart(String str,
                @Nullable
                String strip)
```
    Strip any of a supplied String from the start of a String.
    
    If the strip String is null, whitespace is stripped.
    
    Parameters:
    str - the String to remove characters from
    strip - the String to remove
    
    Returns:
    the stripped String
  - upperCase
```
public static String upperCase(String str)
```
    Convert a String to upper case, null String returns null.
    
    Parameters:
    str - the String to uppercase
    
    Returns:
    the upper cased String
  - lowerCase
```
public static String lowerCase(String str)
```
    Convert a String to lower case, null String returns null.
    
    Parameters:
    str - the string to lowercase
    
    Returns:
    the lower cased String
  - uncapitalise
```
public static String uncapitalise(String str)
```
    Uncapitalise a String.
    
    That is, convert the first character into lower-case. null is returned as null.
    
    Parameters:
    str - the String to uncapitalise
    
    Returns:
    uncapitalised String
  - capitalise
```
public static String capitalise(String str)
```
    Capitalise a String.
    
    That is, convert the first character into title-case. null is returned as null.
    
    Parameters:
    str - the String to capitalise
    
    Returns:
    capitalised String
  - swapCase
```
public static String swapCase(String str)
```
    Swaps the case of String.
    
    Properly looks after making sure the start of words are Titlecase and not Uppercase.
    
    null is returned as null.
    
    Parameters:
    str - the String to swap the case of
    
    Returns:
    the modified String
  - capitaliseAllWords
```
public static String capitaliseAllWords(String str)
```
    Capitalise all the words in a String.
    
    Uses Character.isWhitespace(char) as a separator between words.
    
    null will return null.
    
    Parameters:
    str - the String to capitalise
    
    Returns:
    capitalised String
  - uncapitaliseAllWords
```
public static String uncapitaliseAllWords(String str)
```
    Uncapitalise all the words in a string.
    
    Uses Character.isWhitespace(char) as a separator between words.
    
    null will return null.
    
    Parameters:
    str - the string to uncapitalise
    
    Returns:
    uncapitalised string
  - getNestedString
```
public static String getNestedString(String str,
                     @Nonnull
                     String tag)
```
    Get the String that is nested in between two instances of the same String.
    
    If str is null, will return null.
    
    Parameters:
    str - the String containing nested-string
    tag - the String before and after nested-string
    
    Returns:
    the String that was nested, or null
    
    Throws:
    
    NullPointerException - if tag is null
  - getNestedString
```
public static String getNestedString(String str,
                     @Nonnull
                     String open,
                     @Nonnull
                     String close)
```
    Get the String that is nested in between two Strings.
    
    Parameters:
    str - the String containing nested-string
    open - the String before nested-string
    close - the String after nested-string
    
    Returns:
    the String that was nested, or null
    
    Throws:
    
    NullPointerException - if open or close is null
  - countMatches
```
public static int countMatches(@Nullable
               String str,
               @Nonnull
               String sub)
```
    How many times is the substring in the larger String.
    
    null returns 0.
    
    Parameters:
    str - the String to check
    sub - the substring to count
    
    Returns:
    the number of occurances, 0 if the String is null
    
    Throws:
    
    NullPointerException - if sub is null
  - isAlpha
```
public static boolean isAlpha(String str)
```
    Checks if the String contains only unicode letters.
    
    null will return false. An empty String will return true.
    
    Parameters:
    str - the String to check
    
    Returns:
    true if only contains letters, and is non-null
  - isWhitespace
```
public static boolean isWhitespace(String str)
```
    Checks if the String contains only whitespace.
    
    null will return false. An empty String will return true.
    
    Parameters:
    str - the String to check
    
    Returns:
    true if only contains whitespace, and is non-null
  - isAlphaSpace
```
public static boolean isAlphaSpace(String str)
```
    Checks if the String contains only unicode letters and space (' ').
    
    null will return false. An empty String will return true.
    
    Parameters:
    str - the String to check
    
    Returns:
    true if only contains letters and space, and is non-null
  - isAlphanumeric
```
public static boolean isAlphanumeric(String str)
```
    Checks if the String contains only unicode letters or digits.
    
    null will return false. An empty String will return true.
    
    Parameters:
    str - the String to check
    
    Returns:
    true if only contains letters or digits, and is non-null
  - isAlphanumericSpace
```
public static boolean isAlphanumericSpace(String str)
```
    Checks if the String contains only unicode letters, digits or space (' ').
    
    null will return false. An empty String will return true.
    
    Parameters:
    str - the String to check
    
    Returns:
    true if only contains letters, digits or space, and is non-null
  - isNumeric
```
public static boolean isNumeric(String str)
```
    Checks if the String contains only unicode digits.
    
    null will return false. An empty String will return true.
    
    Parameters:
    str - the String to check
    
    Returns:
    true if only contains digits, and is non-null
  - defaultString
```
@Nonnull
public static String defaultString(Object obj)
```
    Returns either the passed in Object as a String, or, if the Object is null, an empty String.
    
    Parameters:
    obj - the Object to check
    
    Returns:
    the passed in Object's toString, or blank if it was null
  - defaultString
```
@Nonnull
public static String defaultString(Object obj,
                           @Nonnull
                           String defaultString)
```
    Returns either the passed in Object as a String, or, if the Object is null, a passed in default String.
    
    Parameters:
    obj - the Object to check
    defaultString - the default String to return if str is null
    
    Returns:
    the passed in string, or the default if it was null
  - reverse
```
public static String reverse(String str)
```
    Reverse a String.
    
    null String returns null.
    
    Parameters:
    str - the String to reverse
    
    Returns:
    the reversed String
  - reverseDelimitedString
```
@Nonnull
public static String reverseDelimitedString(@Nonnull
                                    String str,
                                    String delimiter)
```
    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 '.').
    
    Parameters:
    str - the String to reverse
    delimiter - the delimiter to use
    
    Returns:
    the reversed String
  - abbreviate
```
@Nonnull
public static String abbreviate(@Nonnull
                        String s,
                        int maxWidth)
```
    Turn "Now is the time for all good men" into "Now is the time for..."
    Specifically:
    If str is less than max characters long, return it. Else abbreviate it to (substring(str, 0, max-3) + "..."). If maxWidth is less than 3, throw an IllegalArgumentException. In no case will it return a string of length greater than maxWidth.
    
    Parameters:
    maxWidth - maximum length of result string
  - abbreviate
```
@Nonnull
public static String abbreviate(@Nonnull
                        String s,
                        int offset,
                        int maxWidth)
```
    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.
    
    Parameters:
    offset - left edge of source string
    maxWidth - maximum length of result string
  - difference
```
public static String difference(@Nonnull
                String s1,
                @Nonnull
                String s2)
```
    Compare two strings, and return the portion where they differ. (More precisely, return the remainder of the second string, starting from where it's different from the first.)
    E.g. strdiff("i am a machine", "i am a robot") -> "robot"
    
    Returns:
    the portion of s2 where it differs from s1; returns the empty string ("") if they are equal
  - differenceAt
```
public static int differenceAt(@Nonnull
               String s1,
               @Nonnull
               String s2)
```
    Compare two strings, and return the index at which the strings begin to differ.
    E.g. strdiff("i am a machine", "i am a robot") -> 7
    
    Returns:
    the index where s2 and s1 begin to differ; -1 if they are equal
  - interpolate
```
public static String interpolate(String text,
                 @Nonnull
                 Map<?,?> namespace)
```
    Fill all 'variables' in the given text with the values from the map. Any text looking like '${key}' will get replaced by the value stored in the namespace map under the 'key'.
    
    Parameters:
    text -
    namespace -
    
    Returns:
    the interpolated text.
  - removeAndHump
```
@Nonnull
public static String removeAndHump(@Nonnull
                           String data,
                           @Nonnull
                           String replaceThis)
```
    This is basically the inverse of addAndDeHump(String). It will remove the 'replaceThis' parameter and uppercase the next character afterwards.
```
 removeAndHump( "this-is-it", %quot;-" );
 
```
    will become 'ThisIsIt'.
    Parameters:
    data -
    replaceThis -
    
    Returns:
    humped String
  - capitalizeFirstLetter
```
@Nonnull
public static String capitalizeFirstLetter(@Nonnull
                                   String data)
```
    Convert the first character of the given String to uppercase. This method will not trim of spaces!
    
    Attention: this method will currently throw a IndexOutOfBoundsException for empty strings!
    
    Parameters:
    data - the String to get capitalized
    
    Returns:
    data string with the first character transformed to uppercase
    
    Throws:
    
    NullPointerException - if data is null
  - lowercaseFirstLetter
```
@Nonnull
public static String lowercaseFirstLetter(@Nonnull
                                  String data)
```
    Convert the first character of the given String to lowercase. This method will not trim of spaces!
    
    Attention: this method will currently throw a IndexOutOfBoundsException for empty strings!
    
    Parameters:
    data - the String to get it's first character lower-cased.
    
    Returns:
    data string with the first character transformed to lowercase
    
    Throws:
    
    NullPointerException - if data is null
  - addAndDeHump
```
@Nonnull
public static String addAndDeHump(@Nonnull
                          String view)
```
    Take the input string and un-camel-case it.
    'ThisIsIt' will become 'this-is-it'.
    
    Parameters:
    view -
    
    Returns:
    deHumped String
  - quoteAndEscape
```
public static String quoteAndEscape(@Nullable
                    String source,
                    char quoteChar)
```
    Quote and escape a String with the given character, handling null.
```
 StringUtils.quoteAndEscape(null, *)    = null
 StringUtils.quoteAndEscape("", *)      = ""
 StringUtils.quoteAndEscape("abc", '"') = abc
 StringUtils.quoteAndEscape("a\"bc", '"') = "a\"bc"
 StringUtils.quoteAndEscape("a\"bc", '\'') = 'a\"bc'
 
```
    Parameters:
    source -
    quoteChar -
    
    Returns:
    the String quoted and escaped
    See Also:
    quoteAndEscape(String, char, char[], char[], char, boolean), quoteAndEscape(String, char, char[], char[], char, boolean)
  - quoteAndEscape
```
public static String quoteAndEscape(@Nullable
                    String source,
                    char quoteChar,
                    @Nonnull
                    char[] quotingTriggers)
```
    Quote and escape a String with the given character, handling null.
    
    Parameters:
    source -
    quoteChar -
    quotingTriggers -
    
    Returns:
    the String quoted and escaped
    See Also:
    quoteAndEscape(String, char, char[], char[], char, boolean)
  - quoteAndEscape
```
public static String quoteAndEscape(@Nullable
                    String source,
                    char quoteChar,
                    @Nonnull
                    char[] escapedChars,
                    char escapeChar,
                    boolean force)
```
    Parameters:
    source -
    quoteChar -
    escapedChars -
    escapeChar -
    force -
    
    Returns:
    the String quoted and escaped
    See Also:
    quoteAndEscape(String, char, char[], char[], char, boolean)
  - quoteAndEscape
```
public static String quoteAndEscape(@Nullable
                    String source,
                    char quoteChar,
                    @Nonnull
                    char[] escapedChars,
                    @Nonnull
                    char[] quotingTriggers,
                    char escapeChar,
                    boolean force)
```
    Parameters:
    source -
    quoteChar -
    escapedChars -
    quotingTriggers -
    escapeChar -
    force -
    
    Returns:
    the String quoted and escaped
  - escape
```
public static String escape(@Nullable
            String source,
            @Nonnull
            char[] escapedChars,
            char escapeChar)
```
    Parameters:
    source -
    escapedChars -
    escapeChar -
    
    Returns:
    the String escaped
  - removeDuplicateWhitespace
```
@Nonnull
public static String removeDuplicateWhitespace(@Nonnull
                                       String s)
```
    Remove all duplicate whitespace characters and line terminators are replaced with a single space.
    
    Parameters:
    s - a not null String
    
    Returns:
    a string with unique whitespace.
  - unifyLineSeparators
```
public static String unifyLineSeparators(@Nullable
                         String s)
```
    Parses the given String and replaces all occurrences of '\n', '\r' and '\r\n' with the system line separator.
    
    Parameters:
    s - a not null String
    
    Returns:
    a String that contains only System line separators.
    See Also:
    unifyLineSeparators(String, String)
  - unifyLineSeparators
```
public static String unifyLineSeparators(@Nullable
                         String s,
                         @Nullable
                         String ls)
```
    Parses the given String and replaces all occurrences of '\n', '\r' and '\r\n' with the system line separator.
    
    Parameters:
    s - a not null String
    ls - the wanted line separator ("\n" on UNIX), if null using the System line separator.
    
    Returns:
    a String that contains only System line separators.
    
    Throws:
    
    IllegalArgumentException - if ls is not '\n', '\r' and '\r\n' characters.
  - contains
```
public static boolean contains(@Nullable
               String str,
               char searchChar)
```
    Checks if String contains a search character, handling null. This method uses String.indexOf(int).
    
    A null or empty ("") String will return false.
```
 StringUtils.contains(null, *)    = false
 StringUtils.contains("", *)      = false
 StringUtils.contains("abc", 'a') = true
 StringUtils.contains("abc", 'z') = false
 
```
    Parameters:
    str - the String to check, may be null
    searchChar - the character to find
    
    Returns:
    true if the String contains the search character, false if not or null string input
  - contains
```
public static boolean contains(@Nullable
               String str,
               @Nullable
               String searchStr)
```
    Checks if String contains a search String, handling null. This method uses String.indexOf(int).
    
    A null String will return false.
```
 StringUtils.contains(null, *)     = false
 StringUtils.contains(*, null)     = false
 StringUtils.contains("", "")      = true
 StringUtils.contains("abc", "")   = true
 StringUtils.contains("abc", "a")  = true
 StringUtils.contains("abc", "z")  = false
 
```
    Parameters:
    str - the String to check, may be null
    searchStr - the String to find, may be null
    
    Returns:
    true if the String contains the search String, false if not or null string input

Class StringUtils

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

StringUtils

Method Detail

clean

trim

deleteWhitespace

isNotEmpty

isEmpty

isBlank

isNotBlank

equals

equalsIgnoreCase

indexOfAny

lastIndexOfAny

substring

substring

left

right

mid

split

split

split

concatenate

join

join

replaceOnce

replace

replace

replaceOnce

replace

replace

overlayString

center

center

chomp

chomp

chompLast

chompLast

getChomp

prechomp

getPrechomp

chop

chopNewline

escape

repeat

rightPad

rightPad

leftPad

leftPad

strip

strip

stripAll

stripAll

stripEnd

stripStart

upperCase

lowerCase

uncapitalise

capitalise

swapCase

capitaliseAllWords

uncapitaliseAllWords

getNestedString

getNestedString

countMatches

isAlpha

isWhitespace

isAlphaSpace

isAlphanumeric

isAlphanumericSpace

isNumeric

defaultString

defaultString

reverse

reverseDelimitedString

abbreviate