Module org.jooq

Class StringUtils

java.lang.Object
org.jooq.tools.StringUtils

public final class StringUtils extends Object

Operations on String that are null safe.

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

The StringUtils class defines certain words related to String handling.

  • null - null
  • empty - a zero-length string ("")
  • space - the space character (' ', char 32)
  • whitespace - the characters defined by Character.isWhitespace(char)
  • trim - the characters <= 32 as in String.trim()

StringUtils handles null input Strings quietly. That is to say that a null input will return null. Where a boolean or int is being returned details vary by method.

A side effect of the null handling is that a NullPointerException should be considered a bug in StringUtils (except for deprecated methods).

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

Since:
1.0
Version:
$Id: StringUtils.java 911986 2010-02-19 21:19:05Z niallp $
Author:
Apache Software Foundation, Apache Jakarta Turbine, Jon S. Stevens, Daniel L. Rall, Greg Coladonato, Ed Korthof, Rand McNeely, Fredrik Westermarck, Holger Krauth, Alexander Day Chaffee, Henning P. Schmiedehausen, Arun Mammen Thomas, Gary Gregory, Phil Steitz, Al Chou, Michael Davey, Reuben Sivan, Chris Hyzer, Scott Johnson
See Also:
String
  • Field Summary

    Fields
    Modifier and Type
    Field
    Description
    static String
    The empty String "".
    static int
    Represents a failed index search.
  • Method Summary

    Modifier and Type
    Method
    Description
    static String
    abbreviate​(String str, int maxWidth)
    Abbreviates a String using ellipses.
    static String
    abbreviate​(String str, int offset, int maxWidth)
    Abbreviates a String using ellipses.
    static boolean
    containsAny​(String str, char... searchChars)
    Checks if the String contains any character in the given set of characters.
    static int
    countMatches​(String str, String sub)
    Counts how many times the substring appears in the larger String.
    static String
    defaultIfBlank​(String str, String defaultStr)
    Returns either the passed in CharSequence, or if the CharSequence is whitespace, empty ("") or null, the value of defaultStr.
    static String
    defaultIfEmpty​(String str, String defaultStr)
    Returns either the passed in String, or if the String is empty or null, the value of defaultStr.
    static <T> T
    defaultIfNull​(T object, T defaultValue)
    Returns a default value if the object passed is null.
    static String
    Returns either the passed in String, or if the String is null, an empty String ("").
    static String
    defaultString​(String str, String defaultStr)
    Returns either the passed in String, or if the String is null, the value of defaultStr.
    static boolean
    equals​(Object o1, Object o2)
    Compares two objects for deep equality, where either one or both objects may be null.
    static boolean
    equals​(String o1, String o2)
    Compares two strings for equality, where either one or both objects may be null.
    static <T> T
    firstNonNull​(T... objects)
    Returns the first non-null argument.
    static boolean
    isBlank​(String str)
    Checks if a String is whitespace, empty ("") or null.
    static boolean
    isEmpty​(String str)
    Checks if a String is empty ("") or null.
    static String
    join​(Object[] array, char separator)
    Joins the elements of the provided array into a single String containing the provided list of elements.
    static String
    join​(Object[] array, char separator, int startIndex, int endIndex)
    Joins the elements of the provided array into a single String containing the provided list of elements.
    static String
    join​(Object[] array, String separator)
    Joins the elements of the provided array into a single String containing the provided list of elements.
    static String
    join​(Object[] array, String separator, int startIndex, int endIndex)
    Joins the elements of the provided array into a single String containing the provided list of elements.
    static <T> String
    join​(T... elements)
    Joins the elements of the provided array into a single String containing the provided list of elements.
    static String
    leftPad​(String str, int size)
    Left pad a String with spaces (' ').
    static String
    leftPad​(String str, int size, char padChar)
    Left pad a String with a specified character.
    static String
    leftPad​(String str, int strSize, int size)
     
    static String
    leftPad​(String str, int strSize, int size, char padChar)
     
    static String
    leftPad​(String str, int strSize, int size, String padStr)
     
    static String
    leftPad​(String str, int size, String padStr)
    Left pad a String with a specified String.
    static String
    replace​(String text, String searchString, String replacement)
    Replaces all occurrences of a String within another String.
    static String
    replace​(String text, String searchString, String replacement, int max)
    Replaces a String with another String inside a larger String, for the first max values of the search String.
    static String
    replaceEach​(String text, String[] searchList, String[] replacementList)
    Replaces all occurrences of Strings within another String.
    static String
    rightPad​(String str, int size)
    Right pad a String with spaces (' ').
    static String
    rightPad​(String str, int size, char padChar)
    Right pad a String with a specified character.
    static String
    rightPad​(String str, int strSize, int size)
     
    static String
    rightPad​(String str, int strSize, int size, char padChar)
     
    static String
    rightPad​(String str, int strSize, int size, String padStr)
     
    static String
    rightPad​(String str, int size, String padStr)
    Right pad a String with a specified String.
    static String[]
    split​(String regex, CharSequence input)
    A custom adaptation of Pattern.split(CharSequence, int).
    static String
    toCamelCase​(String string)
    Convert a string to camel case
    static String
    toCamelCaseLC​(String string)
    Convert a string to camel case starting with a lower case letter
    static String
    toLC​(String string)
    Change a string's first letter to lower case
    static String
    toUC​(String string)
    Change a string's first letter to upper case

    Methods inherited from class java.lang.Object

    clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
  • Field Details

    • EMPTY

      public static final String EMPTY
      The empty String "".
      Since:
      2.0
      See Also:
      Constant Field Values
    • INDEX_NOT_FOUND

      public static final int INDEX_NOT_FOUND
      Represents a failed index search.
      Since:
      2.1
      See Also:
      Constant Field Values
  • Method Details

    • defaultString

      public static String defaultString(String 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"
       
      Parameters:
      str - the String to check, may be null
      Returns:
      the passed in String, or the empty String if it was null
      See Also:
      String.valueOf(Object)
    • defaultString

      public static String defaultString(String str, String defaultStr)

      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"
       
      Parameters:
      str - the String to check, may be null
      defaultStr - the default String to return if the input is null, may be null
      Returns:
      the passed in String, or the default if it was null
      See Also:
      String.valueOf(Object)
    • defaultIfEmpty

      public static String defaultIfEmpty(String str, String defaultStr)

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

       StringUtils.defaultIfEmpty(null, "NULL")  = "NULL"
       StringUtils.defaultIfEmpty("", "NULL")    = "NULL"
       StringUtils.defaultIfEmpty("bat", "NULL") = "bat"
       
      Parameters:
      str - the String to check, may be null
      defaultStr - the default String to return if the input is empty ("") or null, may be null
      Returns:
      the passed in String, or the default
      See Also:
      defaultString(String, String)
    • defaultIfBlank

      public static String defaultIfBlank(String str, String defaultStr)

      Returns either the passed in CharSequence, or if the CharSequence is whitespace, empty ("") or null, the value of defaultStr.

       StringUtils.defaultIfBlank(null, "NULL")  = "NULL"
       StringUtils.defaultIfBlank("", "NULL")    = "NULL"
       StringUtils.defaultIfBlank(" ", "NULL")   = "NULL"
       StringUtils.defaultIfBlank("bat", "NULL") = "bat"
       StringUtils.defaultIfBlank("", null)      = null
       
      Parameters:
      str - the CharSequence to check, may be null
      defaultStr - the default CharSequence to return if the input is whitespace, empty ("") or null, may be null
      Returns:
      the passed in CharSequence, or the default
      See Also:
      defaultString(String, String)
    • isEmpty

      public static boolean isEmpty(String str)

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

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

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

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

      public static boolean isBlank(String str)

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

       StringUtils.isBlank(null)      = true
       StringUtils.isBlank("")        = true
       StringUtils.isBlank(" ")       = true
       StringUtils.isBlank("bob")     = false
       StringUtils.isBlank("  bob  ") = false
       
      Parameters:
      str - the String to check, may be null
      Returns:
      true if the String is null, empty or whitespace
      Since:
      2.0
    • countMatches

      public static int countMatches(String str, String sub)

      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
       
      Parameters:
      str - the String to check, may be null
      sub - the substring to count, may be null
      Returns:
      the number of occurrences, 0 if either String is null
    • rightPad

      public static String rightPad(String str, int 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"
       
      Parameters:
      str - the String to pad out, may be null
      size - the size to pad to
      Returns:
      right padded String or original String if no padding is necessary, null if null String input
    • rightPad

      public static String rightPad(String str, int strSize, int size)
    • rightPad

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

      Right pad a String with a specified character.

      The String is padded to the size of size.

       StringUtils.rightPad(null, *, *)     = null
       StringUtils.rightPad("", 3, 'z')     = "zzz"
       StringUtils.rightPad("bat", 3, 'z')  = "bat"
       StringUtils.rightPad("bat", 5, 'z')  = "batzz"
       StringUtils.rightPad("bat", 1, 'z')  = "bat"
       StringUtils.rightPad("bat", -1, 'z') = "bat"
       
      Parameters:
      str - the String to pad out, may be null
      size - the size to pad to
      padChar - the character to pad with
      Returns:
      right padded String or original String if no padding is necessary, null if null String input
      Since:
      2.0
    • rightPad

      public static String rightPad(String str, int strSize, int size, char padChar)
    • rightPad

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

      Right pad a String with a specified String.

      The String is padded to the size of size.

       StringUtils.rightPad(null, *, *)      = null
       StringUtils.rightPad("", 3, "z")      = "zzz"
       StringUtils.rightPad("bat", 3, "yz")  = "bat"
       StringUtils.rightPad("bat", 5, "yz")  = "batyz"
       StringUtils.rightPad("bat", 8, "yz")  = "batyzyzy"
       StringUtils.rightPad("bat", 1, "yz")  = "bat"
       StringUtils.rightPad("bat", -1, "yz") = "bat"
       StringUtils.rightPad("bat", 5, null)  = "bat  "
       StringUtils.rightPad("bat", 5, "")    = "bat  "
       
      Parameters:
      str - the String to pad out, may be null
      size - the size to pad to
      padStr - the String to pad with, null or empty treated as single space
      Returns:
      right padded String or original String if no padding is necessary, null if null String input
    • rightPad

      public static String rightPad(String str, int strSize, int size, String padStr)
    • leftPad

      public static String leftPad(String str, int 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"
       
      Parameters:
      str - the String to pad out, may be null
      size - the size to pad to
      Returns:
      left padded String or original String if no padding is necessary, null if null String input
    • leftPad

      public static String leftPad(String str, int strSize, int size)
    • leftPad

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

      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"
       
      Parameters:
      str - the String to pad out, may be null
      size - the size to pad to
      padChar - the character to pad with
      Returns:
      left padded String or original String if no padding is necessary, null if null String input
      Since:
      2.0
    • leftPad

      public static String leftPad(String str, int strSize, int size, char padChar)
    • leftPad

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

      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"
       
      Parameters:
      str - the String to pad out, may be null
      size - the size to pad to
      padStr - the String to pad with, null or empty treated as single space
      Returns:
      left padded String or original String if no padding is necessary, null if null String input
    • leftPad

      public static String leftPad(String str, int strSize, int size, String padStr)
    • abbreviate

      public static String abbreviate(String str, int maxWidth)

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

      Specifically:

      • If 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
       
      Parameters:
      str - the String to check, may be null
      maxWidth - maximum length of result String, must be at least 4
      Returns:
      abbreviated String, null if null String input
      Throws:
      IllegalArgumentException - if the width is too small
      Since:
      2.0
    • abbreviate

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

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

      Works like 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
       
      Parameters:
      str - the String to check, may be null
      offset - left edge of source String
      maxWidth - maximum length of result String, must be at least 4
      Returns:
      abbreviated String, null if null String input
      Throws:
      IllegalArgumentException - if the width is too small
      Since:
      2.0
    • containsAny

      public static boolean containsAny(String str, char... searchChars)

      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
       
      Parameters:
      str - the String to check, may be null
      searchChars - the chars to search for, may be null
      Returns:
      the true if any of the chars are found, false if no match or null input
      Since:
      2.4
    • replace

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

      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"
       
      Parameters:
      text - text to search and replace in, may be null
      searchString - the String to search for, may be null
      replacement - the String to replace it with, may be null
      Returns:
      the text with any replacements processed, null if null String input
      See Also:
      replace(String text, String searchString, String replacement, int max)
    • replace

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

      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"
       
      Parameters:
      text - text to search and replace in, may be null
      searchString - the String to search for, may be null
      replacement - the String to replace it with, may be null
      max - maximum number of values to replace, or -1 if no maximum
      Returns:
      the text with any replacements processed, null if null String input
    • replaceEach

      public static String replaceEach(String text, String[] searchList, String[] replacementList)

      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"
       
      Parameters:
      text - text to search and replace in, no-op if null
      searchList - the Strings to search for, no-op if null
      replacementList - the Strings to replace them with, no-op if null
      Returns:
      the text with any replacements processed, null if null String input
      Throws:
      IndexOutOfBoundsException - if the lengths of the arrays are not the same (null is ok, and/or size 0)
      Since:
      2.4
    • join

      @SafeVarargs public static <T> String join(T... elements)

      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"
       
      Type Parameters:
      T - the specific type of values to join together
      Parameters:
      elements - the values to join together, may be null
      Returns:
      the joined String, null if null array input
      Since:
      2.0, 3.0 Changed signature to use varargs
    • join

      public static String join(Object[] array, char 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. 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"
       
      Parameters:
      array - the array of values to join together, may be null
      separator - the separator character to use
      Returns:
      the joined String, null if null array input
      Since:
      2.0
    • join

      public static String join(Object[] array, char separator, int startIndex, int endIndex)

      Joins the elements of the provided array into a single String containing the provided list of elements.

      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"
       
      Parameters:
      array - the array of values to join together, may be null
      separator - the separator character to use
      startIndex - the first index to start joining from. It is an error to pass in an end index past the end of the array
      endIndex - the index to stop joining from (exclusive). It is an error to pass in an end index past the end of the array
      Returns:
      the joined String, null if null array input
      Since:
      2.0
    • join

      public static String join(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 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"
       
      Parameters:
      array - the array of values to join together, may be null
      separator - the separator character to use, null treated as ""
      Returns:
      the joined String, null if null array input
    • join

      public static String join(Object[] array, String separator, int startIndex, int endIndex)

      Joins the elements of the provided array into a single String containing the provided list of elements.

      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"
       
      Parameters:
      array - the array of values to join together, may be null
      separator - the separator character to use, null treated as ""
      startIndex - the first index to start joining from. It is an error to pass in an end index past the end of the array
      endIndex - the index to stop joining from (exclusive). It is an error to pass in an end index past the end of the array
      Returns:
      the joined String, null if null array input
    • equals

      public static boolean equals(String o1, String o2)

      Compares two strings for equality, where either one or both objects may be null.

       ObjectUtils.equals(null, null)                  = true
       ObjectUtils.equals(null, "")                    = false
       ObjectUtils.equals("", null)                    = false
       ObjectUtils.equals("", "")                      = true
       
      Parameters:
      o1 - the first object, may be null
      o2 - the second object, may be null
      Returns:
      true if the values of both objects are the same
    • equals

      public static boolean equals(Object o1, Object o2)

      Compares two objects for deep equality, where either one or both objects may be null.

       ObjectUtils.equals(null, null)                  = true
       ObjectUtils.equals(null, "")                    = false
       ObjectUtils.equals("", null)                    = false
       ObjectUtils.equals("", "")                      = true
       ObjectUtils.equals(Boolean.TRUE, null)          = false
       ObjectUtils.equals(Boolean.TRUE, "true")        = false
       ObjectUtils.equals(Boolean.TRUE, Boolean.TRUE)  = true
       ObjectUtils.equals(Boolean.TRUE, Boolean.FALSE) = false
       
      Parameters:
      o1 - the first object, may be null
      o2 - the second object, may be null
      Returns:
      true if the values of both objects are the same
    • defaultIfNull

      public static <T> T defaultIfNull(T object, T defaultValue)

      Returns a default value if the object passed is null.

       ObjectUtils.defaultIfNull(null, null)      = null
       ObjectUtils.defaultIfNull(null, "")        = ""
       ObjectUtils.defaultIfNull(null, "zz")      = "zz"
       ObjectUtils.defaultIfNull("abc", *)        = "abc"
       ObjectUtils.defaultIfNull(Boolean.TRUE, *) = Boolean.TRUE
       
      Type Parameters:
      T - the type of the object
      Parameters:
      object - the Object to test, may be null
      defaultValue - the default value to return, may be null
      Returns:
      object if it is not null, defaultValue otherwise
    • firstNonNull

      @SafeVarargs public static <T> T firstNonNull(T... objects)

      Returns the first non-null argument.

      Type Parameters:
      T - the type of the objects
      Parameters:
      objects - the elements to test, may not be null but empty
      Returns:
      first non-null element in objects, otherwise null
    • toCamelCase

      public static String toCamelCase(String string)
      Convert a string to camel case
    • toCamelCaseLC

      public static String toCamelCaseLC(String string)
      Convert a string to camel case starting with a lower case letter
    • toLC

      public static String toLC(String string)
      Change a string's first letter to lower case
    • toUC

      public static String toUC(String string)
      Change a string's first letter to upper case
    • split

      public static String[] split(String regex, CharSequence input)
      A custom adaptation of Pattern.split(CharSequence, int).

      This is useful if the matched split-tokens should be returned as well. For example:

       split("e", "hello world")    // ["h", "e", "llo world"]
       split("o", "hello world")    // ["hell", "o", " w", "o", "rld"]
       split("[eo]", "hello world") // ["h", "e", "ll", "o", " w", "o", "rld"]
       

      The result will always be an odd-length array.