StringUtilities (java-util 2.4.8 API)

java.lang.Object
- com.cedarsoftware.util.StringUtilities

```
public final class StringUtilities
extends Object
```
Useful String utilities for common tasks

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 Summary

Fields
Modifier and Type Field and Description

static String EMPTY

static String FOLDER_SEPARATOR

Fields
Modifier and Type	Field and Description
`static String`	`EMPTY`
`static String`	`FOLDER_SEPARATOR`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static int`	`count(CharSequence content, CharSequence token)` Count the number of times that 'token' occurs within 'content'.
`static int`	`count(String s, char c)`
`static String`	`createString(byte[] bytes, String encoding)` Convert a byte[] into a String with a particular encoding.
`static String`	`createUtf8String(byte[] bytes)` Convert a byte[] into a UTF-8 String.
`static String`	`createUTF8String(byte[] bytes)` Convert a byte[] into a UTF-8 encoded String.
`static int`	`damerauLevenshteinDistance(CharSequence source, CharSequence target)` Calculate the Damerau-Levenshtein Distance between two strings.
`static byte[]`	`decode(String s)`
`static String`	`encode(byte[] bytes)` Convert a byte array into a printable format containing a String of hex digit characters (two per byte).
`static boolean`	`equals(CharSequence cs1, CharSequence cs2)` Compares two CharSequences, returning `true` if they represent equal sequences of characters.
`static boolean`	`equals(String s1, String s2)`
`static boolean`	`equalsIgnoreCase(CharSequence cs1, CharSequence cs2)` Compares two CharSequences, returning `true` if they represent equal sequences of characters, ignoring case.
`static boolean`	`equalsIgnoreCase(String s1, String s2)`
`static boolean`	`equalsIgnoreCaseWithTrim(String s1, String s2)`
`static boolean`	`equalsWithTrim(String s1, String s2)`
`static byte[]`	`getBytes(String s, String encoding)` Convert a String into a byte[] with a particular encoding.
`static String`	`getRandomChar(Random random, boolean upper)`
`static String`	`getRandomString(Random random, int minLen, int maxLen)`
`static byte[]`	`getUTF8Bytes(String s)` Convert a String into a byte[] encoded by UTF-8.
`static boolean`	`hasContent(String s)` Checks if a String is not empty (""), not null and not whitespace only.
`static int`	`hashCodeIgnoreCase(String s)` Get the hashCode of a String, insensitive to case, without any new Strings being created on the heap.
`static boolean`	`isEmpty(CharSequence cs)` Checks if a CharSequence is empty (""), null, or only whitespace.
`static boolean`	`isEmpty(String s)`
`static boolean`	`isWhitespace(CharSequence cs)` Checks if a CharSequence is empty (""), null or whitespace only.
`static int`	`lastIndexOf(String path, char ch)`
`static int`	`length(CharSequence cs)` Gets a CharSequence length or `0` if the CharSequence is `null`.
`static int`	`length(String s)`
`static int`	`levenshteinDistance(CharSequence s, CharSequence t)` The Levenshtein distance is a string metric for measuring the difference between two sequences.
`static String`	`trim(String str)` Removes control characters (char <= 32) from both ends of this String, handling `null` by returning `null`.
`static String`	`trimEmptyToDefault(String value, String defaultValue)` Trims a string, If the string trims to empty then we return the default.
`static int`	`trimLength(String s)`
`static String`	`trimToEmpty(String value)` Trims a string, its null safe and null will return empty string here..
`static String`	`trimToNull(String value)` Trims a string, If the string trims to empty then we return null.
`static String`	`wildcardToRegexString(String wildcard)` Convert strings containing DOS-style '*' or '?' to a regex String.

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

- Field Detail
  - FOLDER_SEPARATOR
```
public static String FOLDER_SEPARATOR
```
  - EMPTY
```
public static String EMPTY
```
- Method Detail
  - 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:
    
    equalsIgnoreCase(CharSequence, CharSequence)
  - equals
```
public static boolean equals(String s1,
                             String s2)
```
    See Also:
    
    equals(CharSequence, CharSequence)
  - 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:
    
    equals(CharSequence, CharSequence)
  - equalsIgnoreCase
```
public static boolean equalsIgnoreCase(String s1,
                                       String s2)
```
    See Also:
    
    equalsIgnoreCase(CharSequence, CharSequence)
  - 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:
    
    isEmpty(CharSequence)
  - 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:
    
    length(CharSequence)
  - trimLength
```
public static int trimLength(String s)
```
    Parameters:
    
    s - a String or null
    
    Returns:
    
    the trimmed length of the String or 0 if the string is null.
  - lastIndexOf
```
public static int lastIndexOf(String path,
                              char ch)
```
  - decode
```
public static byte[] decode(String s)
```
  - 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)
```
    Parameters:
    
    random - Random instance
    
    minLen - minimum number of characters
    
    maxLen - maximum number of characters
    
    Returns:
    
    String of alphabetical characters, with the first character uppercase (Proper case strings).
  - getRandomChar
```
public static String 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 String. 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
  - 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
  - createUTF8String
```
public static String createUTF8String(byte[] bytes)
```
    Convert a byte[] into a UTF-8 encoded String.
    
    Parameters:
    
    bytes - bytes to encode into a string
  - 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.
    
    Parameters:
    
    s - String input
    
    Returns:
    
    int hashCode of input String insensitive to case
  - 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

Class StringUtilities

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

FOLDER_SEPARATOR

EMPTY

Method Detail

equals

equals

equalsIgnoreCase

equalsIgnoreCase

equalsWithTrim

equalsIgnoreCaseWithTrim

isEmpty

isEmpty

isWhitespace

hasContent

length

length

trimLength

lastIndexOf

decode

encode

count

count

wildcardToRegexString

levenshteinDistance

damerauLevenshteinDistance

getRandomString

getRandomChar

getBytes

createUtf8String

getUTF8Bytes

createString

createUTF8String

hashCodeIgnoreCase

trim

trimToEmpty

trimToNull

trimEmptyToDefault