Package com.cedarsoftware.util

Class StringUtilities

java.lang.Object
com.cedarsoftware.util.StringUtilities
public final class StringUtilities extends Object
Comprehensive utility class for string operations providing enhanced manipulation, comparison, and conversion capabilities with null-safe implementations.

Key Features

  • String Comparison:
    • Case-sensitive and case-insensitive equality
    • Comparison with automatic trimming
    • Null-safe operations
    • CharSequence support
  • Content Analysis:
    • Empty and whitespace checking
    • String length calculations
    • Character/substring counting
    • Pattern matching with wildcards
  • String Manipulation:
    • Advanced trimming operations
    • Quote handling
    • Encoding conversions
    • Random string generation
  • Distance Metrics:
    • Levenshtein distance calculation
    • Damerau-Levenshtein distance calculation

Security Configuration

StringUtilities provides configurable security controls to prevent various attack vectors. All security features are disabled by default for backward compatibility.

Security controls can be enabled via system properties:

  • stringutilities.security.enabled=false — Master switch for all security features
  • stringutilities.max.hex.decode.size=0 — Max hex string size for decode() (0=disabled)
  • stringutilities.max.wildcard.length=0 — Max wildcard pattern length (0=disabled)
  • stringutilities.max.wildcard.count=0 — Max wildcard characters in pattern (0=disabled)
  • stringutilities.max.levenshtein.string.length=0 — Max string length for Levenshtein distance (0=disabled)
  • stringutilities.max.damerau.levenshtein.string.length=0 — Max string length for Damerau-Levenshtein distance (0=disabled)
  • stringutilities.max.repeat.count=0 — Max repeat count for repeat() method (0=disabled)
  • stringutilities.max.repeat.total.size=0 — Max total size for repeat() result (0=disabled)

Security Features

  • Memory Exhaustion Protection: Limits string sizes to prevent out-of-memory attacks
  • ReDoS Prevention: Limits wildcard pattern complexity to prevent regular expression denial of service
  • Integer Overflow Protection: Prevents arithmetic overflow in size calculations

Usage Examples

String Comparison:


 // Case-sensitive and insensitive comparison
 boolean equals = StringUtilities.equals("text", "text");           // true
 boolean equals = StringUtilities.equalsIgnoreCase("Text", "text"); // true

 // Comparison with trimming
 boolean equals = StringUtilities.equalsWithTrim(" text ", "text"); // true

Content Checking:


 // Empty and whitespace checking
 boolean empty = StringUtilities.isEmpty("   ");      // true
 boolean empty = StringUtilities.isEmpty(null);       // true
 boolean hasContent = StringUtilities.hasContent(" text "); // true

 // Length calculations
 int len = StringUtilities.length(null);             // 0
 int len = StringUtilities.trimLength(" text ");     // 4

String Manipulation:


 // Trimming operations
 String result = StringUtilities.trimToEmpty(null);    // ""
 String result = StringUtilities.trimToNull("  ");     // null
 String result = StringUtilities.trimEmptyToDefault("  ", "default");  // "default"

 // Quote handling
 String result = StringUtilities.removeLeadingAndTrailingQuotes("\"text\"");  // text

 // Set conversion
 Set<String> set = StringUtilities.commaSeparatedStringToSet("a,b,c");  // [a, b, c]

Distance Calculations:


 // Edit distance metrics
 int distance = StringUtilities.levenshteinDistance("kitten", "sitting");        // 3
 int distance = StringUtilities.damerauLevenshteinDistance("book", "back");      // 2

Thread Safety

All methods in this class are stateless and thread-safe.

Author:
Ken Partlow, John DeRegnaucourt ([email protected])
Copyright (c) Cedar Software LLC

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at

License

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

  • Field Details

  • Method Details

    • equals

      public static boolean equals(CharSequence cs1, CharSequence cs2)
      Compares two CharSequences, returning true if they represent equal sequences of characters.

      nulls are handled without exceptions. Two null references are considered to be equal. The comparison is case-sensitive.

      Parameters:
      cs1 - the first CharSequence, may be null
      cs2 - the second CharSequence, may be null
      Returns:
      true if the CharSequences are equal (case-sensitive), or both null
      See Also:

    • equals

      public static boolean equals(String s1, String s2)
      See Also:

    • equalsIgnoreCase

      public static boolean equalsIgnoreCase(CharSequence cs1, CharSequence cs2)
      Compares two CharSequences, returning true if they represent equal sequences of characters, ignoring case.

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

      Parameters:
      cs1 - the first CharSequence, may be null
      cs2 - the second CharSequence, may be null
      Returns:
      true if the CharSequences are equal (case-insensitive), or both null
      See Also:

    • equalsIgnoreCase

      public static boolean equalsIgnoreCase(String s1, String s2)
      See Also:

    • containsIgnoreCase

      public static boolean containsIgnoreCase(String s1, String s2)
      Checks if the first string contains the second string, ignoring case considerations.

      This method uses String.regionMatches(boolean, int, String, int, int) for optimal performance, avoiding the creation of temporary lowercase strings that would be required with s1.toLowerCase().contains(s2.toLowerCase()).

      Parameters:
      s1 - the string to search within, may be null
      s2 - the substring to search for, may be null
      Returns:
      true if s1 contains s2 (case-insensitive), false otherwise. Returns false if either parameter is null.

    • equalsWithTrim

      public static boolean equalsWithTrim(String s1, String s2)

    • equalsIgnoreCaseWithTrim

      public static boolean equalsIgnoreCaseWithTrim(String s1, String s2)

    • isEmpty

      public static boolean isEmpty(CharSequence cs)
      Checks if a CharSequence is empty (""), null, or only whitespace.
      Parameters:
      cs - the CharSequence to check, may be null
      Returns:
      true if the CharSequence is empty or null

    • isEmpty

      public static boolean isEmpty(String s)
      See Also:

    • isWhitespace

      public static boolean isWhitespace(CharSequence cs)
      Checks if a CharSequence is empty (""), null or whitespace only.
      Parameters:
      cs - the CharSequence to check, may be null
      Returns:
      true if the CharSequence is null, empty or whitespace only

    • hasContent

      public static boolean hasContent(String s)
      Checks if a String is not empty (""), not null and not whitespace only.
      Parameters:
      s - the CharSequence to check, may be null
      Returns:
      true if the CharSequence is not empty and not null and not whitespace only

    • length

      public static int length(CharSequence cs)
      Gets a CharSequence length or 0 if the CharSequence is null.
      Parameters:
      cs - a CharSequence or null
      Returns:
      CharSequence length or 0 if the CharSequence is null.

    • length

      public static int length(String s)
      See Also:

    • trimLength

      public static int trimLength(String s)
      Returns the length of the trimmed string. If the length is null then it returns 0.
      Parameters:
      s - the string to get the trimmed length of
      Returns:
      the length of the trimmed string, or 0 if the input is null

    • lastIndexOf

      public static int lastIndexOf(String path, char ch)

    • decode

      public static byte[] decode(String s)
      Convert a hexadecimal String into a byte array.

      If the input length is odd or contains non-hex characters the method returns null.

      Parameters:
      s - the hexadecimal string to decode, may not be null
      Returns:
      the decoded bytes or null if the input is malformed

    • encode

      public static String encode(byte[] bytes)
      Convert a byte array into a printable format containing a String of hex digit characters (two per byte).
      Parameters:
      bytes - array representation

    • count

      public static int count(String s, char c)

    • count

      public static int count(CharSequence content, CharSequence token)
      Count the number of times that 'token' occurs within 'content'.
      Returns:
      int count (0 if it never occurs, null is the source string, or null is the token).

    • wildcardToRegexString

      public static String wildcardToRegexString(String wildcard)
      Convert strings containing DOS-style '*' or '?' to a regex String.

    • levenshteinDistance

      public static int levenshteinDistance(CharSequence s, CharSequence t)
      The Levenshtein distance is a string metric for measuring the difference between two sequences. Informally, the Levenshtein distance between two words is the minimum number of single-character edits (i.e. insertions, deletions or substitutions) required to change one word into the other. The phrase 'edit distance' is often used to refer specifically to Levenshtein distance.
      Parameters:
      s - String one
      t - String two
      Returns:
      the 'edit distance' (Levenshtein distance) between the two strings.

    • damerauLevenshteinDistance

      public static int damerauLevenshteinDistance(CharSequence source, CharSequence target)
      Calculate the Damerau-Levenshtein Distance between two strings. The basic difference between this algorithm and the general Levenshtein algorithm is that damerau-Levenshtein counts a swap of two characters next to each other as 1 instead of 2. This breaks the 'triangular equality', which makes it unusable for Metric trees. See Wikipedia pages on both Levenshtein and Damerau-Levenshtein and then make your decision as to which algorithm is appropriate for your situation.
      Parameters:
      source - Source input string
      target - Target input string
      Returns:
      The number of substitutions it would take to make the source string identical to the target string

    • getRandomString

      public static String getRandomString(Random random, int minLen, int maxLen)
      Generate a random proper‑case string.
      Parameters:
      random - Random instance, must not be null
      minLen - minimum number of characters (inclusive)
      maxLen - maximum number of characters (inclusive)
      Returns:
      alphabetic string with the first character uppercase
      Throws:
      NullPointerException - if random is null
      IllegalArgumentException - if length parameters are invalid

    • getRandomChar

      public static char getRandomChar(Random random, boolean upper)

    • getBytes

      public static byte[] getBytes(String s, String encoding)
      Convert a String into a byte[] with a particular encoding. Preferable used when the encoding is one of the guaranteed Java types and you don't want to have to catch the UnsupportedEncodingException required by Java
      Parameters:
      s - string to encode into bytes
      encoding - encoding to use

    • createUTF8String

      public static String createUTF8String(byte[] bytes)
      Convert a byte[] into a UTF-8 encoded String.
      Parameters:
      bytes - bytes to encode into a string

    • getUTF8Bytes

      public static byte[] getUTF8Bytes(String s)
      Convert a String into a byte[] encoded by UTF-8.
      Parameters:
      s - string to encode into bytes

    • createString

      public static String createString(byte[] bytes, String encoding)
      Convert a byte[] into a String with a particular encoding. Preferable used when the encoding is one of the guaranteed Java types and you don't want to have to catch the UnsupportedEncodingException required by Java
      Parameters:
      bytes - bytes to encode into a string
      encoding - encoding to use

    • hashCodeIgnoreCase

      public static int hashCodeIgnoreCase(CharSequence cs)
      Computes a case-insensitive hash code for a CharSequence. This method produces the same hash as cs.toString().toLowerCase().hashCode() for compatibility with existing code.
      Parameters:
      cs - the CharSequence to hash (can be String, StringBuilder, etc.)
      Returns:
      the case-insensitive hash code, or 0 if cs is null

    • hashCodeIgnoreCase

      public static int hashCodeIgnoreCase(String s)
      Get the hashCode of a String, insensitive to case, without any new Strings being created on the heap.

      This implementation uses a fast ASCII shift approach for compatible locales, and falls back to the more correct but slower Locale-aware approach for locales where simple ASCII case conversion does not work properly.

    • trim

      public static String trim(String str)
      Removes control characters (char <= 32) from both ends of this String, handling null by returning null.

      The String is trimmed using String.trim(). Trim removes start and end characters <= 32.

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

    • trimToEmpty

      public static String trimToEmpty(String value)
      Trims a string, its null safe and null will return empty string here..
      Parameters:
      value - string input
      Returns:
      String trimmed string, if value was null this will be empty

    • trimToNull

      public static String trimToNull(String value)
      Trims a string, If the string trims to empty then we return null.
      Parameters:
      value - string input
      Returns:
      String, trimmed from value. If the value was empty we return null.

    • trimEmptyToDefault

      public static String trimEmptyToDefault(String value, String defaultValue)
      Trims a string, If the string trims to empty then we return the default.
      Parameters:
      value - string input
      defaultValue - value to return on empty or null
      Returns:
      trimmed string, or defaultValue when null or empty

    • removeLeadingAndTrailingQuotes

      public static String removeLeadingAndTrailingQuotes(String input)
      Removes all leading and trailing double quotes from a String. Multiple consecutive quotes at the beginning or end of the string will all be removed.

      Examples:

      • "text" → text
      • ""text"" → text
      • """text""" → text
      • "text with "quotes" inside" → text with "quotes" inside
      Parameters:
      input - the String from which to remove quotes (may be null)
      Returns:
      the String with all leading and trailing quotes removed, or null if input was null

    • commaSeparatedStringToSet

      public static Set<String> commaSeparatedStringToSet(String commaSeparatedString)
      Converts a comma-separated string into a Set of trimmed, non-empty strings.

      This method splits the provided string by commas, trims whitespace from each resulting substring, filters out any empty strings, and collects the unique strings into a Set. If the input string is null or empty after trimming, the method returns an empty set.

      Usage Example: 

      
 String csv = "apple, banana, cherry, apple,  ";
 Set<String> fruitSet = commaSeparatedStringToSet(csv);
 // fruitSet contains ["apple", "banana", "cherry"]

      Note: The resulting Set does not maintain the insertion order. If order preservation is required, consider using a LinkedHashSet.

      Parameters:
      commaSeparatedString - the comma-separated string to convert
      Returns:
      a mutable Set containing the trimmed, unique, non-empty substrings from the input string. Returns an empty LinkedHashSet if the input is null, empty, or contains only whitespace.
      Throws:
      IllegalArgumentException - if the method is modified to disallow null inputs in the future
      See Also:

    • snakeToCamel

      public static String snakeToCamel(String snake)
      Convert a snake_case string to camelCase.
      Parameters:
      snake - the snake case string, may be null
      Returns:
      the camelCase representation or null if snake is null

    • camelToSnake

      public static String camelToSnake(String camel)
      Convert a camelCase or PascalCase string to snake_case.
      Parameters:
      camel - the camel case string, may be null
      Returns:
      the snake_case representation or null if camel is null

    • isNumeric

      public static boolean isNumeric(String s)
      Determine if the supplied string contains only numeric digits.
      Parameters:
      s - the string to test, may be null
      Returns:
      true if s is non-empty and consists solely of digits

    • repeat

      public static String repeat(String s, int count)
      Repeat a string count times.
      Parameters:
      s - the string to repeat, may be null
      count - the number of times to repeat, must be non-negative
      Returns:
      the repeated string or null if s is null
      Throws:
      IllegalArgumentException - if count is negative

    • reverse

      public static String reverse(String s)
      Reverse the characters of a string.
      Parameters:
      s - the string to reverse, may be null
      Returns:
      the reversed string or null if s is null

    • padLeft

      public static String padLeft(String s, int length)
      Pad the supplied string on the left with spaces until it reaches the specified length. If the string is already longer than length, the original string is returned.
      Parameters:
      s - the string to pad, may be null
      length - desired final length
      Returns:
      the padded string or null if s is null

    • padRight

      public static String padRight(String s, int length)
      Pad the supplied string on the right with spaces until it reaches the specified length. If the string is already longer than length, the original string is returned.
      Parameters:
      s - the string to pad, may be null
      length - desired final length
      Returns:
      the padded string or null if s is null