StringHelper (ph-commons 6.0.1 API)

java.lang.Object
- com.helger.commons.string.StringHelper

```
@Immutable
public final class StringHelper
extends Object
```
Generic string transformation and helper methods. If you need to modify a string, start looking in this class.

Author:

Philip Helger

Field Summary

Fields
Modifier and Type Field and Description

static int STRING_NOT_FOUND
The constant to be returned if an String.indexOf call did not find a match!

Fields
Modifier and Type	Field and Description
`static int`	`STRING_NOT_FOUND` The constant to be returned if an String.indexOf call did not find a match!

Method Summary

Methods
Modifier and Type	Method and Description
`static boolean`	`contains(String sText, char cSearch)` Check if cSearch is contained within sText.
`static boolean`	`contains(String sText, String sSearch)` Check if sSearch is contained within sText.
`static boolean`	`containsAny(char[] aInput, char[] aSearchChars)` Check if any of the passed searched characters is contained in the input char array.
`static boolean`	`containsAny(String sInput, char[] aSearchChars)` Check if any of the passed searched characters in contained in the input string.
`static boolean`	`containsIgnoreCase(String sText, char cSearch, Locale aSortLocale)` Check if cSearch is contained within sText ignoring case.
`static boolean`	`containsIgnoreCase(String sText, String sSearch, Locale aSortLocale)` Check if sSearch is contained within sText ignoring case.
`static boolean`	`endsWith(CharSequence aCS, char c)`
`static boolean`	`endsWith(CharSequence aCS, CharSequence aSearch)`
`static boolean`	`endsWithAny(CharSequence aCS, char[] aChars)`
`static boolean`	`endsWithIgnoreCase(CharSequence aCS, char c)`
`static boolean`	`endsWithIgnoreCase(String sStr, String sSearch)`
`static int`	`getCharacterCount(int nValue)` Get the number of characters the passed value would occupy in a string representation.
`static int`	`getCharacterCount(long nValue)` Get the number of characters the passed value would occupy in a string representation.
`static int`	`getCharCount(char[] aChars, char cSearch)`
`static int`	`getCharCount(String s, char cSearch)`
`static String`	`getConcatenatedOnDemand(String sFront, char cSep, String sEnd)` Concatenate the strings sFront and sEnd by the "cSep" separator.
`static String`	`getConcatenatedOnDemand(String sFront, String sEnd)` Concatenate the strings sFront and sEnd.
`static String`	`getConcatenatedOnDemand(String sFront, String sSep, String sEnd)` Concatenate the strings sFront and sEnd by the "sSep" string.
`static String`	`getCutAfterLength(String sValue, int nMaxLength)`
`static String`	`getCutAfterLength(String sValue, int nMaxLength, String sNewSuffix)`
`static List<String>`	`getExploded(char cSep, String sElements)` Take a concatenated String and return a `List` of all elements in the passed string, using specified separator string.
`static List<String>`	`getExploded(char cSep, String sElements, int nMaxItems)` Take a concatenated String and return a `List` of all elements in the passed string, using specified separator string.
`static <COLLTYPE extends Collection<String>> COLLTYPE`	`getExploded(char cSep, String sElements, int nMaxItems, COLLTYPE aCollection)` Take a concatenated String and return the passed Collection of all elements in the passed string, using specified separator string.
`static List<String>`	`getExploded(String sSep, String sElements)` Take a concatenated String and return a `List` of all elements in the passed string, using specified separator string.
`static List<String>`	`getExploded(String sSep, String sElements, int nMaxItems)` Take a concatenated String and return a `List` of all elements in the passed string, using specified separator string.
`static <COLLTYPE extends Collection<String>> COLLTYPE`	`getExploded(String sSep, String sElements, int nMaxItems, COLLTYPE aCollection)` Take a concatenated String and return the passed Collection of all elements in the passed string, using specified separator string.
`static String[]`	`getExplodedArray(char cSep, String sElements)` Take a concatenated String and return the passed String array of all elements in the passed string, using specified separator char.
`static String[]`	`getExplodedArray(char cSep, String sElements, int nMaxItems)` Take a concatenated String and return the passed String array of all elements in the passed string, using specified separator char.
`static Set<String>`	`getExplodedToOrderedSet(String sSep, String sElements)` Take a concatenated String and return an ordered `LinkedHashSet` of all elements in the passed string, using specified separator string.
`static Set<String>`	`getExplodedToSet(String sSep, String sElements)` Take a concatenated String and return a `Set` of all elements in the passed string, using specified separator string.
`static SortedSet<String>`	`getExplodedToSortedSet(String sSep, String sElements)` Take a concatenated String and return a sorted `TreeSet` of all elements in the passed string, using specified separator string.
`static char`	`getFirstChar(char[] aChars)` Get the first character of the passed array
`static char`	`getFirstChar(CharSequence aCS)` Get the first character of the passed character sequence
`static String`	`getFirstToken(String sStr, char cSearch)` Get the first token up to (and excluding) the separating character.
`static String`	`getFirstToken(String sStr, String sSearch)` Get the first token up to (and excluding) the separating string.
`static String`	`getFromFirstExcl(String sStr, char cSearch)` Get everything from the string from and excluding the first passed char.
`static String`	`getFromFirstExcl(String sStr, String sSearch)` Get everything from the string from and excluding the passed string.
`static String`	`getFromFirstIncl(String sStr, char cSearch)` Get everything from the string from and including the first passed char.
`static String`	`getFromFirstIncl(String sStr, String sSearch)` Get everything from the string from and including the passed string.
`static String`	`getFromLastExcl(String sStr, char cSearch)` Get everything from the string from and excluding the first passed char.
`static String`	`getFromLastExcl(String sStr, String sSearch)` Get everything from the string from and excluding the passed string.
`static String`	`getFromLastIncl(String sStr, char cSearch)` Get everything from the string from and including the first passed char.
`static String`	`getFromLastIncl(String sStr, String sSearch)` Get everything from the string from and including the passed string.
`static int`	`getHexByte(char cHigh, char cLow)`
`static char`	`getHexChar(int n)` Get the matching hex digit as a lower case character.
`static char`	`getHexCharUpperCase(int n)` Get the matching hex digit as an upper case character.
`static byte[]`	`getHexDecoded(char[] aInput)`
`static byte[]`	`getHexDecoded(char[] aInput, int nOfs, int nLen)`
`static byte[]`	`getHexDecoded(String sInput)`
`static String`	`getHexEncoded(byte[] aInput)` Convert a byte array to a hexadecimal encoded string.
`static String`	`getHexEncoded(byte[] aInput, int nOfs, int nLen)` Convert a byte array to a hexadecimal encoded string.
`static String`	`getHexEncoded(String sInput, Charset aCharset)` Convert a string to a byte array and than to a hexadecimal encoded string.
`static String`	`getHexString(byte nValue)`
`static String`	`getHexString(int nValue)`
`static String`	`getHexString(long nValue)`
`static String`	`getHexString(short nValue)`
`static String`	`getHexStringLeadingZero(byte nValue, int nDigits)`
`static String`	`getHexStringLeadingZero(int nValue, int nDigits)`
`static String`	`getHexStringLeadingZero(long nValue, int nDigits)`
`static String`	`getHexStringLeadingZero(short nValue, int nDigits)`
`static String`	`getHexStringLeadingZero2(byte nValue)`
`static int`	`getHexValue(char c)` Get the decimal value of the passed hex character
`static String`	`getImploded(char cSepOuter, char cSepInner, Map<?,?> aElements)` Get a concatenated String from all elements of the passed map, separated by the specified separator chars.
`static <ELEMENTTYPE> String`	`getImploded(char cSep, ELEMENTTYPE... aElements)` Get a concatenated String from all elements of the passed array, separated by the specified separator char.
`static <ELEMENTTYPE> String`	`getImploded(char cSep, ELEMENTTYPE[] aElements, int nOfs, int nLen)` Get a concatenated String from all elements of the passed array, separated by the specified separator char.
`static String`	`getImploded(char cSep, Iterable<?> aElements)` Get a concatenated String from all elements of the passed container, separated by the specified separator char.
`static <ELEMENTTYPE> String`	`getImploded(ELEMENTTYPE... aElements)` Get a concatenated String from all elements of the passed array, without a separator.
`static <ELEMENTTYPE> String`	`getImploded(ELEMENTTYPE[] aElements, int nOfs, int nLen)` Get a concatenated String from all elements of the passed array, without a separator.
`static String`	`getImploded(Iterable<?> aElements)` Get a concatenated String from all elements of the passed container, without a separator.
`static <ELEMENTTYPE> String`	`getImploded(String sSep, ELEMENTTYPE... aElements)` Get a concatenated String from all elements of the passed array, separated by the specified separator string.
`static <ELEMENTTYPE> String`	`getImploded(String sSep, ELEMENTTYPE[] aElements, int nOfs, int nLen)` Get a concatenated String from all elements of the passed array, separated by the specified separator string.
`static String`	`getImploded(String sSep, Iterable<?> aElements)` Get a concatenated String from all elements of the passed container, separated by the specified separator string.
`static String`	`getImploded(String sSepOuter, String sSepInner, Map<?,?> aElements)` Get a concatenated String from all elements of the passed map, separated by the specified separator strings.
`static String`	`getImplodedNonEmpty(char cSep, Iterable<String> aElements)` Get a concatenated String from all non-`null` and non empty elements of the passed container, separated by the specified separator char.
`static String`	`getImplodedNonEmpty(char cSep, String... aElements)` Get a concatenated String from all elements of the passed array, separated by the specified separator char.
`static String`	`getImplodedNonEmpty(char cSep, String[] aElements, int nOfs, int nLen)` Get a concatenated String from all elements of the passed array, separated by the specified separator char.
`static String`	`getImplodedNonEmpty(Iterable<String> aElements)` Get a concatenated String from all non-`null` and non empty elements of the passed container without a separator string.
`static String`	`getImplodedNonEmpty(String sSep, Iterable<String> aElements)` Get a concatenated String from all non-`null` and non empty elements of the passed container, separated by the specified separator string.
`static String`	`getImplodedNonEmpty(String sSep, String... aElements)` Get a concatenated String from all elements of the passed array, separated by the specified separator string.
`static String`	`getImplodedNonEmpty(String sSep, String[] aElements, int nOfs, int nLen)` Get a concatenated String from all elements of the passed array, separated by the specified separator string.
`static int`	`getIndexOf(String sText, char cSearch)` Get the first index of cSearch within sText.
`static int`	`getIndexOf(String sText, int nFromIndex, char cSearch)` Get the first index of cSearch within sText starting at index nFromIndex.
`static int`	`getIndexOf(String sText, int nFromIndex, String sSearch)` Get the first index of sSearch within sText starting at index nFromIndex.
`static int`	`getIndexOf(String sText, String sSearch)` Get the first index of sSearch within sText.
`static int`	`getIndexOfIgnoreCase(String sText, char cSearch, Locale aSortLocale)` Get the first index of cSearch within sText ignoring case.
`static int`	`getIndexOfIgnoreCase(String sText, int nFromIndex, char cSearch, Locale aSortLocale)` Get the first index of cSearch within sText ignoring case starting at index nFromIndex.
`static int`	`getIndexOfIgnoreCase(String sText, int nFromIndex, String sSearch, Locale aSortLocale)` Get the first index of sSearch within sText ignoring case starting at index nFromIndex.
`static int`	`getIndexOfIgnoreCase(String sText, String sSearch, Locale aSortLocale)` Get the first index of sSearch within sText ignoring case.
`static char`	`getLastChar(char[] aChars)` Get the last character of the passed array
`static char`	`getLastChar(CharSequence aCS)` Get the last character of the passed character sequence
`static int`	`getLastIndexOf(String sText, char cSearch)` Get the last index of cSearch within sText.
`static int`	`getLastIndexOf(String sText, int nFromIndex, char cSearch)` Get the last index of cSearch within sText starting at index nFromIndex.
`static int`	`getLastIndexOf(String sText, int nFromIndex, String sSearch)` Get the last index of sSearch within sText starting at index nFromIndex.
`static int`	`getLastIndexOf(String sText, String sSearch)` Get the last index of sSearch within sText.
`static int`	`getLastIndexOfIgnoreCase(String sText, char cSearch, Locale aSortLocale)` Get the last index of cSearch within sText ignoring case.
`static int`	`getLastIndexOfIgnoreCase(String sText, int nFromIndex, char cSearch, Locale aSortLocale)` Get the last index of cSearch within sText ignoring case starting at index nFromIndex.
`static int`	`getLastIndexOfIgnoreCase(String sText, int nFromIndex, String sSearch, Locale aSortLocale)` Get the last index of sSearch within sText ignoring case starting at index nFromIndex.
`static int`	`getLastIndexOfIgnoreCase(String sText, String sSearch, Locale aSortLocale)` Get the last index of sSearch within sText ignoring case.
`static String`	`getLastToken(String sStr, char cSearch)` Get the last token from (and excluding) the separating character.
`static String`	`getLastToken(String sStr, String sSearch)` Get the last token from (and excluding) the separating string.
`static int`	`getLeadingCharCount(String s, char c)` Get the number of specified chars, the passed string starts with.
`static int`	`getLeadingWhitespaceCount(String s)` Get the number of leading white spaces according to `Character.isWhitespace(char)`
`static String`	`getLeadingZero(Byte aValue, int nChars)`
`static String`	`getLeadingZero(Integer aValue, int nChars)`
`static String`	`getLeadingZero(int nValue, int nChars)`
`static String`	`getLeadingZero(long nValue, int nChars)`
`static String`	`getLeadingZero(Long aValue, int nChars)`
`static String`	`getLeadingZero(Short aValue, int nChars)`
`static String`	`getLeadingZero(String sValue, int nChars)`
`static int`	`getLength(CharSequence aCS)` Get the length of the passed character sequence.
`static int`	`getLineCount(String s)`
`static int`	`getLineCount(String s, char cLineSep)`
`static CharSequence`	`getNotNull(CharSequence s)` Get the passed `CharSequence` but never return `null`.
`static CharSequence`	`getNotNull(CharSequence s, CharSequence sDefaultIfNull)` Get the passed `CharSequence` but never return `null`.
`static String`	`getNotNull(String s)` Get the passed string but never return `null`.
`static String`	`getNotNull(String s, String sDefaultIfNull)` Get the passed string but never return `null`.
`static int`	`getOccurrenceCount(String sText, char cSearch)` Count the number of occurrences of cSearch within sText.
`static int`	`getOccurrenceCount(String sText, String sSearch)` Count the number of occurrences of sSearch within sText.
`static int`	`getOccurrenceCountIgnoreCase(String sText, char cSearch, Locale aSortLocale)` Count the number of occurrences of cSearch within sText ignoring case.
`static int`	`getOccurrenceCountIgnoreCase(String sText, String sSearch, Locale aSortLocale)` Count the number of occurrences of sSearch within sText ignoring case.
`static String`	`getRepeated(char cElement, int nRepeats)` Get the passed string element repeated for a certain number of times.
`static String`	`getRepeated(String sElement, int nRepeats)` Get the passed string element repeated for a certain number of times.
`static int`	`getReplaceMultipleResultLength(char[] aInputString, char[] aSearchChars, char[][] aReplacementStrings)` Get the result length (in characters) when replacing all patterns with the replacements on the passed input array.
`static String`	`getReverse(String sStr)`
`static String`	`getToString(Object aObject)` Convert the passed object to a string using the `Object.toString()` method.
`static String`	`getToString(Object aObject, String sNullValue)` Convert the passed object to a string using the `Object.toString()` method or otherwise return the passed default value.
`static int`	`getTrailingCharCount(String s, char c)` Get the number of specified chars, the passed string ends with.
`static int`	`getTrailingWhitespaceCount(String s)` Get the number of trailing white spaces according to `Character.isWhitespace(char)`
`static String`	`getUntilFirstExcl(String sStr, char cSearch)` Get everything from the string up to and excluding first the passed char.
`static String`	`getUntilFirstExcl(String sStr, String sSearch)` Get everything from the string up to and excluding the first passed string.
`static String`	`getUntilFirstIncl(String sStr, char cSearch)` Get everything from the string up to and including the first passed char.
`static String`	`getUntilFirstIncl(String sStr, String sSearch)` Get everything from the string up to and including the first passed string.
`static String`	`getUntilLastExcl(String sStr, char cSearch)` Get everything from the string up to and excluding first the passed char.
`static String`	`getUntilLastExcl(String sStr, String sSearch)` Get everything from the string up to and excluding the first passed string.
`static String`	`getUntilLastIncl(String sStr, char cSearch)` Get everything from the string up to and including the first passed char.
`static String`	`getUntilLastIncl(String sStr, String sSearch)` Get everything from the string up to and including the first passed string.
`static String`	`getWithLeading(String sValue, int nChars, char cPrefix)`
`static String`	`getWithoutAnySpaces(String sStr)` Get the passed string where all spaces (white spaces or unicode spaces) have been removed.
`static String`	`getWithoutLeadingChar(String sStr)` Get the passed string without the first char.
`static String`	`getWithoutLeadingChars(String sStr, int nCount)` Get the passed string without the specified number of leading chars.
`static String`	`getWithoutTrailingChar(String sStr)` Get the passed string without the last char.
`static String`	`getWithoutTrailingChars(String sStr, int nCount)` Get the passed string without the specified number of trailing chars.
`static boolean`	`hasNoText(CharSequence aCS)` Check if the string is `null` or empty.
`static boolean`	`hasNoText(String sStr)` Check if the string is `null` or empty.
`static boolean`	`hasNoTextAfterTrim(String s)` Check if the string is `null` or empty after trimming.
`static boolean`	`hasText(CharSequence aCS)` Check if the string contains any char.
`static boolean`	`hasText(String sStr)` Check if the string contains any char.
`static boolean`	`hasTextAfterTrim(String s)` Check if the string neither `null` nor empty after trimming.
`static boolean`	`isAllWhitespace(CharSequence s)` Check if the passed character sequence is only whitespace or not.
`static boolean`	`isEmpty(CharSequence aCS)` Check if the string is `null` or empty.
`static boolean`	`isEmpty(String sStr)` Check if the string is `null` or empty.
`static boolean`	`isEmptyAfterTrim(String s)` Check if the string is `null` or empty after trimming.
`static boolean`	`isNotEmpty(CharSequence aCS)` Check if the string contains any char.
`static boolean`	`isNotEmpty(String sStr)` Check if the string contains any char.
`static boolean`	`isNotEmptyAfterTrim(String s)` Check if the string neither `null` nor empty after trimming.
`static String`	`removeAll(String sInputString, char cRemoveChar)` Remove all occurrences of the passed character from the specified input string
`static String`	`removeMultiple(String sInputString, char[] aRemoveChars)` Optimized remove method that removes a set of characters from an input string!
`static String`	`replaceAll(String sInputString, char cSearchChar, char cReplacementChar)` This is a fast replacement for `String.replace(CharSequence, CharSequence)` for characters.
`static String`	`replaceAll(String sInputString, String sSearchText, CharSequence aReplacementText)` This is a fast replacement for `String.replace(CharSequence, CharSequence)`.
`static String`	`replaceAllRepeatedly(String sInputString, String sSearchText, String sReplacementText)` Just calls `replaceAll` as long as there are still replacements found
`static String`	`replaceAllSafe(String sInputString, String sSearchText, CharSequence aReplacementText)` Same as `replaceAll(String, String, CharSequence)` but allowing for a `null` new-value, which is than interpreted as an empty string instead.
`static char[]`	`replaceMultiple(char[] aInput, char[] aSearchChars, char[][] aReplacementStrings)` Optimized replace method that replaces a set of characters with a set of strings.
`static char[]`	`replaceMultiple(String sInputString, char[] aSearchChars, char cReplacementChar)` Optimized replace method that replaces a set of characters with another character.
`static char[]`	`replaceMultiple(String sInputString, char[] aSearchChars, char[][] aReplacementStrings)` Optimized replace method that replaces a set of characters with a set of strings.
`static String`	`replaceMultiple(String sInputString, Map<String,String> aTransTable)` Perform all string replacements on the input string as defined by the passed map.
`static String`	`replaceMultiple(String sInputString, String[] aSearchTexts, String[] aReplacementTexts)` Perform all string replacements on the input string as defined by the passed map.
`static int`	`replaceMultipleTo(char[] aInput, char[] aSearchChars, char[][] aReplacementStrings, Writer aTarget)` Specialized version of `replaceMultiple(String, char[], char[][])` where the object where the output should be appended is passed in as a parameter.
`static int`	`replaceMultipleTo(String sInputString, char[] aSearchChars, char[][] aReplacementStrings, Writer aTarget)` Specialized version of `replaceMultiple(String, char[], char[][])` where the object where the output should be appended is passed in as a parameter.
`static boolean`	`startsWith(CharSequence aCS, char c)`
`static boolean`	`startsWith(CharSequence aCS, CharSequence aSearch)`
`static boolean`	`startsWithAny(CharSequence aCS, char[] aChars)`
`static boolean`	`startsWithIgnoreCase(CharSequence aCS, char c)`
`static boolean`	`startsWithIgnoreCase(String sStr, String sSearch)`
`static String`	`trim(String s)` Trim the passed string, if it is not `null`.
`static String`	`trimEnd(String sSrc, int nCount)` Trim the passed tail from the source value.
`static String`	`trimEnd(String sSrc, String sTail)` Trim the passed tail from the source value.
`static String`	`trimLeadingWhitespaces(String s)` Remove any leading whitespaces from the passed string.
`static String`	`trimStart(String sSrc, int nCount)` Trim the passed lead from the source value.
`static String`	`trimStart(String sSrc, String sLead)` Trim the passed lead from the source value.
`static String`	`trimStartAndEnd(String sSrc, String sValueToTrim)` Trim the passed lead and tail from the source value.
`static String`	`trimStartAndEnd(String sSrc, String sLead, String sTail)` Trim the passed lead and tail from the source value.
`static String`	`trimTrailingWhitespaces(String s)` Remove any trailing whitespaces from the passed string.

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

- Field Detail
  - STRING_NOT_FOUND
```
public static final int STRING_NOT_FOUND
```
    The constant to be returned if an String.indexOf call did not find a match!
    
    See Also:
    Constant Field Values
- Method Detail
  - hasNoText
```
public static boolean hasNoText(@Nullable
                CharSequence aCS)
```
    Check if the string is null or empty.
    
    Parameters:
    aCS - The character sequence to check. May be null.
    
    Returns:
    true if the string is null or empty, false otherwise
  - hasNoText
```
public static boolean hasNoText(@Nullable
                String sStr)
```
    Check if the string is null or empty.
    
    Parameters:
    sStr - The string to check. May be null.
    
    Returns:
    true if the string is null or empty, false otherwise
  - isEmpty
```
public static boolean isEmpty(@Nullable
              CharSequence aCS)
```
    Check if the string is null or empty.
    
    Parameters:
    aCS - The character sequence to check. May be null.
    
    Returns:
    true if the string is null or empty, false otherwise
  - isEmpty
```
public static boolean isEmpty(@Nullable
              String sStr)
```
    Check if the string is null or empty.
    
    Parameters:
    sStr - The string to check. May be null.
    
    Returns:
    true if the string is null or empty, false otherwise
  - hasNoTextAfterTrim
```
public static boolean hasNoTextAfterTrim(@Nullable
                         String s)
```
    Check if the string is null or empty after trimming.
    
    Parameters:
    s - The string to check. May be null.
    
    Returns:
    true if the string is null or empty or consists only of whitespaces, false otherwise
  - isEmptyAfterTrim
```
public static boolean isEmptyAfterTrim(@Nullable
                       String s)
```
    Check if the string is null or empty after trimming.
    
    Parameters:
    s - The string to check. May be null.
    
    Returns:
    true if the string is null or empty or consists only of whitespaces, false otherwise
  - hasText
```
public static boolean hasText(@Nullable
              CharSequence aCS)
```
    Check if the string contains any char.
    
    Parameters:
    aCS - The character sequence to check. May be null.
    
    Returns:
    true if the string contains at least one, false otherwise
  - hasText
```
public static boolean hasText(@Nullable
              String sStr)
```
    Check if the string contains any char.
    
    Parameters:
    sStr - The string to check. May be null.
    
    Returns:
    true if the string contains at least one char, false otherwise
  - isNotEmpty
```
public static boolean isNotEmpty(@Nullable
                 CharSequence aCS)
```
    Check if the string contains any char.
    
    Parameters:
    aCS - The character sequence to check. May be null.
    
    Returns:
    true if the string contains at least one char, false otherwise
  - isNotEmpty
```
public static boolean isNotEmpty(@Nullable
                 String sStr)
```
    Check if the string contains any char.
    
    Parameters:
    sStr - The string to check. May be null.
    
    Returns:
    true if the string contains at least one char, false otherwise
  - hasTextAfterTrim
```
public static boolean hasTextAfterTrim(@Nullable
                       String s)
```
    Check if the string neither null nor empty after trimming.
    
    Parameters:
    s - The string to check. May be null.
    
    Returns:
    true if the string is neither null nor empty nor consists only of whitespaces, false otherwise
  - isNotEmptyAfterTrim
```
public static boolean isNotEmptyAfterTrim(@Nullable
                          String s)
```
    Check if the string neither null nor empty after trimming.
    
    Parameters:
    s - The string to check. May be null.
    
    Returns:
    true if the string is neither null nor empty nor consists only of whitespaces, false otherwise
  - isAllWhitespace
```
public static boolean isAllWhitespace(@Nonnull
                      CharSequence s)
```
    Check if the passed character sequence is only whitespace or not.
    
    Parameters:
    s - The character sequence to be checked. May not be null.
    
    Returns:
    true if the passed sequence is empty or if only whitespace characters are contained.
    See Also:
    Character.isWhitespace(char)
  - getLeadingZero
```
@Nullable
public static String getLeadingZero(@Nullable
                             Byte aValue,
                             int nChars)
```
  - getLeadingZero
```
@Nullable
public static String getLeadingZero(@Nullable
                             Integer aValue,
                             int nChars)
```
  - getLeadingZero
```
@Nullable
public static String getLeadingZero(@Nullable
                             Long aValue,
                             int nChars)
```
  - getLeadingZero
```
@Nullable
public static String getLeadingZero(@Nullable
                             Short aValue,
                             int nChars)
```
  - getLeadingZero
```
@Nonnull
public static String getLeadingZero(int nValue,
                            int nChars)
```
  - getLeadingZero
```
@Nonnull
public static String getLeadingZero(long nValue,
                            int nChars)
```
  - getLeadingZero
```
@Nonnull
public static String getLeadingZero(@Nonnull
                            String sValue,
                            int nChars)
```
  - getWithLeading
```
@Nonnull
public static String getWithLeading(@Nonnull
                            String sValue,
                            int nChars,
                            char cPrefix)
```
  - getHexChar
```
public static char getHexChar(int n)
```
    Get the matching hex digit as a lower case character.
    
    Parameters:
    n - The value to get the hex digit from. Must be between 0 and 15.
    
    Returns:
    The hex character (one of 0-9 or a-f), or '\0' if the value could not be converted
  - getHexCharUpperCase
```
public static char getHexCharUpperCase(int n)
```
    Get the matching hex digit as an upper case character.
    
    Parameters:
    n - The value to get the hex digit from. Must be between 0 and 15.
    
    Returns:
    The hex character (one of 0-9 or A-F), or '\0' if the value could not be converted
  - getHexEncoded
```
@Nonnull
public static String getHexEncoded(@Nonnull
                           String sInput,
                           @Nonnull
                           Charset aCharset)
```
    Convert a string to a byte array and than to a hexadecimal encoded string.
    
    Parameters:
    sInput - The source string. May not be null.
    aCharset - The charset to use. May not be null.
    
    Returns:
    The String representation of the byte array of the string.
  - getHexEncoded
```
@Nonnull
public static String getHexEncoded(@Nonnull
                           byte[] aInput)
```
    Convert a byte array to a hexadecimal encoded string.
    
    Parameters:
    aInput - The byte array to be converted to a String. May not be null.
    
    Returns:
    The String representation of the byte array.
  - getHexEncoded
```
@Nonnull
public static String getHexEncoded(@Nonnull
                           byte[] aInput,
                           int nOfs,
                           int nLen)
```
    Convert a byte array to a hexadecimal encoded string.
    
    Parameters:
    aInput - The byte array to be converted to a String. May not be null.
    nOfs - Byte array offset
    nLen - Number of bytes to encode
    
    Returns:
    The String representation of the byte array.
  - getHexValue
```
@CheckForSigned
public static int getHexValue(@Nonnegative
                             char c)
```
    Get the decimal value of the passed hex character
    
    Parameters:
    c - The hex char to convert
    
    Returns:
    A value between 0 and 15, or -1 if the input character is not a hex char!
  - getHexByte
```
public static int getHexByte(@Nonnegative
             char cHigh,
             @Nonnegative
             char cLow)
```
    Parameters:
    cHigh - High hex part
    cLow - Low hex part
    
    Returns:
    A value between 0 and 255, or -1 if any input character is not a hex char!
  - getHexDecoded
```
@Nonnull
@ReturnsMutableCopy
public static byte[] getHexDecoded(@Nonnull
                                              String sInput)
```
  - getHexDecoded
```
@Nonnull
@ReturnsMutableCopy
public static byte[] getHexDecoded(@Nonnull
                                              char[] aInput)
```
  - getHexDecoded
```
@Nonnull
@ReturnsMutableCopy
public static byte[] getHexDecoded(@Nonnull
                                              char[] aInput,
                                              @Nonnegative
                                              int nOfs,
                                              @Nonnegative
                                              int nLen)
```
  - getHexString
```
@Nonnull
public static String getHexString(byte nValue)
```
  - getHexStringLeadingZero
```
@Nonnull
public static String getHexStringLeadingZero(byte nValue,
                                     int nDigits)
```
  - getHexStringLeadingZero2
```
@Nonnull
public static String getHexStringLeadingZero2(byte nValue)
```
  - getHexString
```
@Nonnull
public static String getHexString(int nValue)
```
  - getHexStringLeadingZero
```
@Nonnull
public static String getHexStringLeadingZero(int nValue,
                                     int nDigits)
```
  - getHexString
```
@Nonnull
public static String getHexString(long nValue)
```
  - getHexStringLeadingZero
```
@Nonnull
public static String getHexStringLeadingZero(long nValue,
                                     int nDigits)
```
  - getHexString
```
@Nonnull
public static String getHexString(short nValue)
```
  - getHexStringLeadingZero
```
@Nonnull
public static String getHexStringLeadingZero(short nValue,
                                     int nDigits)
```
  - getLeadingWhitespaceCount
```
@Nonnegative
public static int getLeadingWhitespaceCount(@Nullable
                                        String s)
```
    Get the number of leading white spaces according to Character.isWhitespace(char)
    
    Parameters:
    s - The string to be parsed. May be null.
    
    Returns:
    Always ≥ 0.
  - getTrailingWhitespaceCount
```
@Nonnegative
public static int getTrailingWhitespaceCount(@Nullable
                                         String s)
```
    Get the number of trailing white spaces according to Character.isWhitespace(char)
    
    Parameters:
    s - The string to be parsed. May be null.
    
    Returns:
    Always ≥ 0.
  - getLeadingCharCount
```
@Nonnegative
public static int getLeadingCharCount(@Nullable
                                  String s,
                                  char c)
```
    Get the number of specified chars, the passed string starts with.
    
    Parameters:
    s - The string to be parsed. May be null.
    c - The char to be searched.
    
    Returns:
    Always ≥ 0.
  - getTrailingCharCount
```
@Nonnegative
public static int getTrailingCharCount(@Nullable
                                   String s,
                                   char c)
```
    Get the number of specified chars, the passed string ends with.
    
    Parameters:
    s - The string to be parsed. May be null.
    c - The char to be searched.
    
    Returns:
    Always ≥ 0.
  - getImploded
```
@Nonnull
public static String getImploded(@Nullable
                         Iterable<?> aElements)
```
    Get a concatenated String from all elements of the passed container, without a separator. Even null elements are added.
    
    Parameters:
    aElements - The container to convert. May be null or empty.
    
    Returns:
    The concatenated string.
  - getImploded
```
@Nonnull
public static String getImploded(@Nonnull
                         String sSep,
                         @Nullable
                         Iterable<?> aElements)
```
    Get a concatenated String from all elements of the passed container, separated by the specified separator string. Even null elements are added.
    
    Parameters:
    sSep - The separator to use. May not be null.
    aElements - The container to convert. May be null or empty.
    
    Returns:
    The concatenated string.
  - getImploded
```
@Nonnull
public static String getImploded(char cSep,
                         @Nullable
                         Iterable<?> aElements)
```
    Get a concatenated String from all elements of the passed container, separated by the specified separator char. Even null elements are added.
    
    Parameters:
    cSep - The separator to use.
    aElements - The container to convert. May be null or empty.
    
    Returns:
    The concatenated string.
  - getImploded
```
@Nonnull
public static String getImploded(@Nonnull
                         String sSepOuter,
                         @Nonnull
                         String sSepInner,
                         @Nullable
                         Map<?,?> aElements)
```
    Get a concatenated String from all elements of the passed map, separated by the specified separator strings.
    
    Parameters:
    sSepOuter - The separator to use for separating the map entries. May not be null.
    sSepInner - The separator to use for separating the key from the value. May not be null.
    aElements - The map to convert. May be null or empty.
    
    Returns:
    The concatenated string.
  - getImploded
```
@Nonnull
public static String getImploded(char cSepOuter,
                         char cSepInner,
                         @Nullable
                         Map<?,?> aElements)
```
    Get a concatenated String from all elements of the passed map, separated by the specified separator chars.
    
    Parameters:
    cSepOuter - The separator to use for separating the map entries.
    cSepInner - The separator to use for separating the key from the value.
    aElements - The map to convert. May be null or empty.
    
    Returns:
    The concatenated string.
  - getImploded
```
@Nonnull
public static <ELEMENTTYPE> String getImploded(@Nullable
                                       ELEMENTTYPE... aElements)
```
    Get a concatenated String from all elements of the passed array, without a separator.
    
    Type Parameters:
    ELEMENTTYPE - The type of elements to be imploded.
    Parameters:
    aElements - The container to convert. May be null or empty.
    
    Returns:
    The concatenated string.
  - getImploded
```
@Nonnull
public static <ELEMENTTYPE> String getImploded(@Nullable
                                       ELEMENTTYPE[] aElements,
                                       @Nonnegative
                                       int nOfs,
                                       @Nonnegative
                                       int nLen)
```
    Get a concatenated String from all elements of the passed array, without a separator.
    
    Type Parameters:
    ELEMENTTYPE - The type of elements to be imploded.
    Parameters:
    aElements - The container to convert. May be null or empty.
    nOfs - The offset to start from.
    nLen - The number of elements to implode.
    
    Returns:
    The concatenated string.
  - getImploded
```
@Nonnull
public static <ELEMENTTYPE> String getImploded(@Nonnull
                                       String sSep,
                                       @Nullable
                                       ELEMENTTYPE... aElements)
```
    Get a concatenated String from all elements of the passed array, separated by the specified separator string.
    
    Type Parameters:
    ELEMENTTYPE - The type of elements to be imploded.
    Parameters:
    sSep - The separator to use. May not be null.
    aElements - The container to convert. May be null or empty.
    
    Returns:
    The concatenated string.
  - getImploded
```
@Nonnull
public static <ELEMENTTYPE> String getImploded(char cSep,
                                       @Nullable
                                       ELEMENTTYPE... aElements)
```
    Get a concatenated String from all elements of the passed array, separated by the specified separator char.
    
    Type Parameters:
    ELEMENTTYPE - The type of elements to be imploded.
    Parameters:
    cSep - The separator to use.
    aElements - The container to convert. May be null or empty.
    
    Returns:
    The concatenated string.
  - getImploded
```
@Nonnull
public static <ELEMENTTYPE> String getImploded(@Nonnull
                                       String sSep,
                                       @Nullable
                                       ELEMENTTYPE[] aElements,
                                       @Nonnegative
                                       int nOfs,
                                       @Nonnegative
                                       int nLen)
```
    Get a concatenated String from all elements of the passed array, separated by the specified separator string.
    
    Type Parameters:
    ELEMENTTYPE - The type of elements to be imploded.
    Parameters:
    sSep - The separator to use. May not be null.
    aElements - The container to convert. May be null or empty.
    nOfs - The offset to start from.
    nLen - The number of elements to implode.
    
    Returns:
    The concatenated string.
  - getImploded
```
@Nonnull
public static <ELEMENTTYPE> String getImploded(char cSep,
                                       @Nullable
                                       ELEMENTTYPE[] aElements,
                                       @Nonnegative
                                       int nOfs,
                                       @Nonnegative
                                       int nLen)
```
    Get a concatenated String from all elements of the passed array, separated by the specified separator char.
    
    Type Parameters:
    ELEMENTTYPE - The type of elements to be imploded.
    Parameters:
    cSep - The separator to use.
    aElements - The container to convert. May be null or empty.
    nOfs - The offset to start from.
    nLen - The number of elements to implode.
    
    Returns:
    The concatenated string.
  - getImplodedNonEmpty
```
@Nonnull
public static String getImplodedNonEmpty(@Nullable
                                 Iterable<String> aElements)
```
    Get a concatenated String from all non-null and non empty elements of the passed container without a separator string. This the very generic version of getConcatenatedOnDemand(String, String) for an arbitrary number of elements.
    
    Parameters:
    aElements - The container to convert. May be null or empty.
    
    Returns:
    The concatenated string.
  - getImplodedNonEmpty
```
@Nonnull
public static String getImplodedNonEmpty(@Nonnull
                                 String sSep,
                                 @Nullable
                                 Iterable<String> aElements)
```
    Get a concatenated String from all non-null and non empty elements of the passed container, separated by the specified separator string. This the very generic version of getConcatenatedOnDemand(String, String, String) for an arbitrary number of elements.
    
    Parameters:
    sSep - The separator to use. May not be null.
    aElements - The container to convert. May be null or empty.
    
    Returns:
    The concatenated string.
  - getImplodedNonEmpty
```
@Nonnull
public static String getImplodedNonEmpty(char cSep,
                                 @Nullable
                                 Iterable<String> aElements)
```
    Get a concatenated String from all non-null and non empty elements of the passed container, separated by the specified separator char. This the very generic version of getConcatenatedOnDemand(String, String, String) for an arbitrary number of elements.
    
    Parameters:
    cSep - The separator to use.
    aElements - The container to convert. May be null or empty.
    
    Returns:
    The concatenated string.
  - getImplodedNonEmpty
```
@Nonnull
public static String getImplodedNonEmpty(@Nonnull
                                 String sSep,
                                 @Nullable
                                 String... aElements)
```
    Get a concatenated String from all elements of the passed array, separated by the specified separator string. This the very generic version of getConcatenatedOnDemand(String, String, String) for an arbitrary number of elements.
    
    Parameters:
    sSep - The separator to use. May not be null.
    aElements - The container to convert. May be null or empty.
    
    Returns:
    The concatenated string.
  - getImplodedNonEmpty
```
@Nonnull
public static String getImplodedNonEmpty(char cSep,
                                 @Nullable
                                 String... aElements)
```
    Get a concatenated String from all elements of the passed array, separated by the specified separator char. This the very generic version of getConcatenatedOnDemand(String, String, String) for an arbitrary number of elements.
    
    Parameters:
    cSep - The separator to use.
    aElements - The container to convert. May be null or empty.
    
    Returns:
    The concatenated string.
  - getImplodedNonEmpty
```
@Nonnull
public static String getImplodedNonEmpty(@Nonnull
                                 String sSep,
                                 @Nullable
                                 String[] aElements,
                                 @Nonnegative
                                 int nOfs,
                                 @Nonnegative
                                 int nLen)
```
    Get a concatenated String from all elements of the passed array, separated by the specified separator string. This the very generic version of getConcatenatedOnDemand(String, String, String) for an arbitrary number of elements.
    
    Parameters:
    sSep - The separator to use. May not be null.
    aElements - The container to convert. May be null or empty.
    nOfs - The offset to start from.
    nLen - The number of elements to implode.
    
    Returns:
    The concatenated string.
  - getImplodedNonEmpty
```
@Nonnull
public static String getImplodedNonEmpty(char cSep,
                                 @Nullable
                                 String[] aElements,
                                 @Nonnegative
                                 int nOfs,
                                 @Nonnegative
                                 int nLen)
```
    Get a concatenated String from all elements of the passed array, separated by the specified separator char. This the very generic version of getConcatenatedOnDemand(String, String, String) for an arbitrary number of elements.
    
    Parameters:
    cSep - The separator to use.
    aElements - The container to convert. May be null or empty.
    nOfs - The offset to start from.
    nLen - The number of elements to implode.
    
    Returns:
    The concatenated string.
  - getExplodedArray
```
@Nonnull
public static String[] getExplodedArray(char cSep,
                                @Nullable
                                String sElements,
                                @CheckForSigned
                                int nMaxItems)
```
    Take a concatenated String and return the passed String array of all elements in the passed string, using specified separator char.
    
    Parameters:
    cSep - The separator to use.
    sElements - The concatenated String to convert. May be null or empty.
    nMaxItems - The maximum number of items to explode. If the passed value is ≤ 0 all items are used. If max items is 1, than the result string is returned as is. If max items is larger than the number of elements found, it has no effect.
    
    Returns:
    The passed collection and never null.
  - getExplodedArray
```
@Nonnull
public static String[] getExplodedArray(char cSep,
                                @Nullable
                                String sElements)
```
    Take a concatenated String and return the passed String array of all elements in the passed string, using specified separator char.
    
    Parameters:
    cSep - The separator to use.
    sElements - The concatenated String to convert. May be null or empty.
    
    Returns:
    The passed collection and never null.
  - getExploded
```
@Nonnull
@ReturnsMutableObject(value="The passed parameter")
public static <COLLTYPE extends Collection<String>> COLLTYPE getExploded(char cSep,
                                                                                           @Nullable
                                                                                           String sElements,
                                                                                           int nMaxItems,
                                                                                           @Nonnull
                                                                                           COLLTYPE aCollection)
```
    Take a concatenated String and return the passed Collection of all elements in the passed string, using specified separator string.
    
    Type Parameters:
    COLLTYPE - The collection type to be passed and returned
    Parameters:
    cSep - The separator to use.
    sElements - The concatenated String to convert. May be null or empty.
    nMaxItems - The maximum number of items to explode. If the passed value is ≤ 0 all items are used. If max items is 1, than the result string is returned as is. If max items is larger than the number of elements found, it has no effect.
    aCollection - The non-null target collection that should be filled with the exploded elements
    
    Returns:
    The passed collection and never null.
  - getExploded
```
@Nonnull
@ReturnsMutableCopy
public static List<String> getExploded(char cSep,
                                                  @Nullable
                                                  String sElements)
```
    Take a concatenated String and return a List of all elements in the passed string, using specified separator string.
    
    Parameters:
    cSep - The separator character to use.
    sElements - The concatenated String to convert. May be null or empty.
    
    Returns:
    The List represented by the passed string. Never null. If the passed input string is null or "" an empty list is returned.
  - getExploded
```
@Nonnull
@ReturnsMutableCopy
public static List<String> getExploded(char cSep,
                                                  @Nullable
                                                  String sElements,
                                                  int nMaxItems)
```
    Take a concatenated String and return a List of all elements in the passed string, using specified separator string.
    
    Parameters:
    cSep - The separator character to use.
    sElements - The concatenated String to convert. May be null or empty.
    nMaxItems - The maximum number of items to explode. If the passed value is ≤ 0 all items are used. If max items is 1, than the result string is returned as is. If max items is larger than the number of elements found, it has no effect.
    
    Returns:
    The List represented by the passed string. Never null. If the passed input string is null or "" an empty list is returned.
  - getExploded
```
@Nonnull
public static <COLLTYPE extends Collection<String>> COLLTYPE getExploded(@Nonnull
                                                                 String sSep,
                                                                 @Nullable
                                                                 String sElements,
                                                                 int nMaxItems,
                                                                 @Nonnull
                                                                 COLLTYPE aCollection)
```
    Take a concatenated String and return the passed Collection of all elements in the passed string, using specified separator string.
    
    Type Parameters:
    COLLTYPE - The collection type to be used and returned
    Parameters:
    sSep - The separator to use. May not be null.
    sElements - The concatenated String to convert. May be null or empty.
    nMaxItems - The maximum number of items to explode. If the passed value is ≤ 0 all items are used. If max items is 1, than the result string is returned as is. If max items is larger than the number of elements found, it has no effect.
    aCollection - The non-null target collection that should be filled with the exploded elements
    
    Returns:
    The passed collection and never null.
  - getExploded
```
@Nonnull
@ReturnsMutableCopy
public static List<String> getExploded(@Nonnull
                                                  String sSep,
                                                  @Nullable
                                                  String sElements)
```
    Take a concatenated String and return a List of all elements in the passed string, using specified separator string.
    
    Parameters:
    sSep - The separator to use. May not be null.
    sElements - The concatenated String to convert. May be null or empty.
    
    Returns:
    The List represented by the passed string. Never null. If the passed input string is null or "" an empty list is returned.
  - getExploded
```
@Nonnull
@ReturnsMutableCopy
public static List<String> getExploded(@Nonnull
                                                  String sSep,
                                                  @Nullable
                                                  String sElements,
                                                  int nMaxItems)
```
    Take a concatenated String and return a List of all elements in the passed string, using specified separator string.
    
    Parameters:
    sSep - The separator to use. May not be null.
    sElements - The concatenated String to convert. May be null or empty.
    nMaxItems - The maximum number of items to explode. If the passed value is ≤ 0 all items are used. If max items is 1, than the result string is returned as is. If max items is larger than the number of elements found, it has no effect.
    
    Returns:
    The List represented by the passed string. Never null. If the passed input string is null or "" an empty list is returned.
  - getExplodedToSet
```
@Nonnull
@ReturnsMutableCopy
public static Set<String> getExplodedToSet(@Nonnull
                                                      String sSep,
                                                      @Nullable
                                                      String sElements)
```
    Take a concatenated String and return a Set of all elements in the passed string, using specified separator string.
    
    Parameters:
    sSep - The separator to use. May not be null.
    sElements - The concatenated String to convert. May be null or empty.
    
    Returns:
    The Set represented by the passed string. Never null. If the passed input string is null or "" an empty list is returned.
  - getExplodedToOrderedSet
```
@Nonnull
@ReturnsMutableCopy
public static Set<String> getExplodedToOrderedSet(@Nonnull
                                                             String sSep,
                                                             @Nullable
                                                             String sElements)
```
    Take a concatenated String and return an ordered LinkedHashSet of all elements in the passed string, using specified separator string.
    
    Parameters:
    sSep - The separator to use. May not be null.
    sElements - The concatenated String to convert. May be null or empty.
    
    Returns:
    The ordered Set represented by the passed string. Never null. If the passed input string is null or "" an empty list is returned.
  - getExplodedToSortedSet
```
@Nonnull
@ReturnsMutableCopy
public static SortedSet<String> getExplodedToSortedSet(@Nonnull
                                                                  String sSep,
                                                                  @Nullable
                                                                  String sElements)
```
    Take a concatenated String and return a sorted TreeSet of all elements in the passed string, using specified separator string.
    
    Parameters:
    sSep - The separator to use. May not be null.
    sElements - The concatenated String to convert. May be null or empty.
    
    Returns:
    The sorted Set represented by the passed string. Never null. If the passed input string is null or "" an empty list is returned.
  - getRepeated
```
@Nonnull
public static String getRepeated(char cElement,
                         @Nonnegative
                         int nRepeats)
```
    Get the passed string element repeated for a certain number of times. Each string element is simply appended at the end of the string.
    
    Parameters:
    cElement - The character to get repeated.
    nRepeats - The number of repetitions to retrieve. May not be < 0.
    
    Returns:
    A non-null string containing the string element for the given number of times.
  - getRepeated
```
@Nonnull
public static String getRepeated(@Nonnull
                         String sElement,
                         @Nonnegative
                         int nRepeats)
```
    Get the passed string element repeated for a certain number of times. Each string element is simply appended at the end of the string.
    
    Parameters:
    sElement - The string to get repeated. May not be null.
    nRepeats - The number of repetitions to retrieve. May not be < 0.
    
    Returns:
    A non-null string containing the string element for the given number of times.
  - getConcatenatedOnDemand
```
@Nonnull
public static String getConcatenatedOnDemand(@Nullable
                                     String sFront,
                                     @Nullable
                                     String sEnd)
```
    Concatenate the strings sFront and sEnd. If either front or back is null or empty only the other element is returned. If both strings are null or empty and empty String is returned.
    
    Parameters:
    sFront - Front string. May be null.
    sEnd - May be null.
    
    Returns:
    The concatenated string. Never null.
  - getConcatenatedOnDemand
```
@Nonnull
public static String getConcatenatedOnDemand(@Nullable
                                     String sFront,
                                     @Nullable
                                     String sSep,
                                     @Nullable
                                     String sEnd)
```
    Concatenate the strings sFront and sEnd by the "sSep" string. If either front or back is null or empty, the separator is not applied.
    
    Parameters:
    sFront - Front string. May be null.
    sSep - Separator string. May be null.
    sEnd - May be null.
    
    Returns:
    The concatenated string.
  - getConcatenatedOnDemand
```
@Nonnull
public static String getConcatenatedOnDemand(@Nullable
                                     String sFront,
                                     char cSep,
                                     @Nullable
                                     String sEnd)
```
    Concatenate the strings sFront and sEnd by the "cSep" separator. If either front or back is null or empty, the separator is not applied.
    
    Parameters:
    sFront - Front string. May be null.
    cSep - Separator character.
    sEnd - May be null.
    
    Returns:
    The concatenated string.
  - startsWith
```
public static boolean startsWith(@Nullable
                 CharSequence aCS,
                 char c)
```
  - startsWithAny
```
public static boolean startsWithAny(@Nullable
                    CharSequence aCS,
                    @Nullable
                    char[] aChars)
```
  - startsWithIgnoreCase
```
public static boolean startsWithIgnoreCase(@Nullable
                           CharSequence aCS,
                           char c)
```
  - startsWith
```
public static boolean startsWith(@Nullable
                 CharSequence aCS,
                 @Nullable
                 CharSequence aSearch)
```
  - startsWithIgnoreCase
```
public static boolean startsWithIgnoreCase(@Nullable
                           String sStr,
                           @Nullable
                           String sSearch)
```
  - endsWith
```
public static boolean endsWith(@Nullable
               CharSequence aCS,
               char c)
```
  - endsWithAny
```
public static boolean endsWithAny(@Nullable
                  CharSequence aCS,
                  @Nullable
                  char[] aChars)
```
  - endsWith
```
public static boolean endsWith(@Nullable
               CharSequence aCS,
               @Nullable
               CharSequence aSearch)
```
  - endsWithIgnoreCase
```
public static boolean endsWithIgnoreCase(@Nullable
                         CharSequence aCS,
                         char c)
```
  - endsWithIgnoreCase
```
public static boolean endsWithIgnoreCase(@Nullable
                         String sStr,
                         @Nullable
                         String sSearch)
```
  - getIndexOf
```
public static int getIndexOf(@Nullable
             String sText,
             @Nullable
             String sSearch)
```
    Get the first index of sSearch within sText.
    
    Parameters:
    sText - The text to search in. May be null.
    sSearch - The text to search for. May be null.
    
    Returns:
    The first index of sSearch within sText or -1 if sSearch was not found or if any parameter was null.
    See Also:
    String.indexOf(String)
  - getIndexOf
```
public static int getIndexOf(@Nullable
             String sText,
             @Nonnegative
             int nFromIndex,
             @Nullable
             String sSearch)
```
    Get the first index of sSearch within sText starting at index nFromIndex.
    
    Parameters:
    sText - The text to search in. May be null.
    nFromIndex - The index to start searching in the source string
    sSearch - The text to search for. May be null.
    
    Returns:
    The first index of sSearch within sText or -1 if sSearch was not found or if any parameter was null.
    See Also:
    String.indexOf(String,int)
  - getLastIndexOf
```
public static int getLastIndexOf(@Nullable
                 String sText,
                 @Nullable
                 String sSearch)
```
    Get the last index of sSearch within sText.
    
    Parameters:
    sText - The text to search in. May be null.
    sSearch - The text to search for. May be null.
    
    Returns:
    The last index of sSearch within sText or -1 if sSearch was not found or if any parameter was null.
    See Also:
    String.lastIndexOf(String)
  - getLastIndexOf
```
public static int getLastIndexOf(@Nullable
                 String sText,
                 @Nonnegative
                 int nFromIndex,
                 @Nullable
                 String sSearch)
```
    Get the last index of sSearch within sText starting at index nFromIndex.
    
    Parameters:
    sText - The text to search in. May be null.
    nFromIndex - The index to start searching in the source string
    sSearch - The text to search for. May be null.
    
    Returns:
    The last index of sSearch within sText or -1 if sSearch was not found or if any parameter was null.
    See Also:
    String.lastIndexOf(String,int)
  - getIndexOf
```
public static int getIndexOf(@Nullable
             String sText,
             char cSearch)
```
    Get the first index of cSearch within sText.
    
    Parameters:
    sText - The text to search in. May be null.
    cSearch - The character to search for. May be null.
    
    Returns:
    The first index of sSearch within sText or -1 if cSearch was not found or if any parameter was null.
    See Also:
    String.indexOf(int)
  - getIndexOf
```
public static int getIndexOf(@Nullable
             String sText,
             @Nonnegative
             int nFromIndex,
             char cSearch)
```
    Get the first index of cSearch within sText starting at index nFromIndex.
    
    Parameters:
    sText - The text to search in. May be null.
    nFromIndex - The index to start searching in the source string
    cSearch - The character to search for. May be null.
    
    Returns:
    The first index of sSearch within sText or -1 if cSearch was not found or if any parameter was null.
    See Also:
    String.indexOf(int,int)
  - getLastIndexOf
```
public static int getLastIndexOf(@Nullable
                 String sText,
                 char cSearch)
```
    Get the last index of cSearch within sText.
    
    Parameters:
    sText - The text to search in. May be null.
    cSearch - The character to search for. May be null.
    
    Returns:
    The last index of sSearch within sText or -1 if cSearch was not found or if any parameter was null.
    See Also:
    String.lastIndexOf(int)
  - getLastIndexOf
```
public static int getLastIndexOf(@Nullable
                 String sText,
                 @Nonnegative
                 int nFromIndex,
                 char cSearch)
```
    Get the last index of cSearch within sText starting at index nFromIndex.
    
    Parameters:
    sText - The text to search in. May be null.
    nFromIndex - The index to start searching in the source string
    cSearch - The character to search for. May be null.
    
    Returns:
    The last index of sSearch within sText or -1 if cSearch was not found or if any parameter was null.
    See Also:
    String.lastIndexOf(int,int)
  - getIndexOfIgnoreCase
```
public static int getIndexOfIgnoreCase(@Nullable
                       String sText,
                       @Nullable
                       String sSearch,
                       @Nonnull
                       Locale aSortLocale)
```
    Get the first index of sSearch within sText ignoring case.
    
    Parameters:
    sText - The text to search in. May be null.
    sSearch - The text to search for. May be null.
    aSortLocale - The locale to be used for case unifying.
    
    Returns:
    The first index of sSearch within sText or -1 if sSearch was not found or if any parameter was null.
    See Also:
    String.indexOf(String)
  - getIndexOfIgnoreCase
```
public static int getIndexOfIgnoreCase(@Nullable
                       String sText,
                       @Nonnegative
                       int nFromIndex,
                       @Nullable
                       String sSearch,
                       @Nonnull
                       Locale aSortLocale)
```
    Get the first index of sSearch within sText ignoring case starting at index nFromIndex.
    
    Parameters:
    sText - The text to search in. May be null.
    nFromIndex - The index to start searching in the source string
    sSearch - The text to search for. May be null.
    aSortLocale - The locale to be used for case unifying.
    
    Returns:
    The first index of sSearch within sText or -1 if sSearch was not found or if any parameter was null.
    See Also:
    String.indexOf(String)
  - getLastIndexOfIgnoreCase
```
public static int getLastIndexOfIgnoreCase(@Nullable
                           String sText,
                           @Nullable
                           String sSearch,
                           @Nonnull
                           Locale aSortLocale)
```
    Get the last index of sSearch within sText ignoring case.
    
    Parameters:
    sText - The text to search in. May be null.
    sSearch - The text to search for. May be null.
    aSortLocale - The locale to be used for case unifying.
    
    Returns:
    The last index of sSearch within sText or -1 if sSearch was not found or if any parameter was null.
    See Also:
    String.lastIndexOf(String)
  - getLastIndexOfIgnoreCase
```
public static int getLastIndexOfIgnoreCase(@Nullable
                           String sText,
                           @Nonnegative
                           int nFromIndex,
                           @Nullable
                           String sSearch,
                           @Nonnull
                           Locale aSortLocale)
```
    Get the last index of sSearch within sText ignoring case starting at index nFromIndex.
    
    Parameters:
    sText - The text to search in. May be null.
    nFromIndex - The index to start searching in the source string
    sSearch - The text to search for. May be null.
    aSortLocale - The locale to be used for case unifying.
    
    Returns:
    The last index of sSearch within sText or -1 if sSearch was not found or if any parameter was null.
    See Also:
    String.lastIndexOf(String)
  - getIndexOfIgnoreCase
```
public static int getIndexOfIgnoreCase(@Nullable
                       String sText,
                       char cSearch,
                       @Nonnull
                       Locale aSortLocale)
```
    Get the first index of cSearch within sText ignoring case.
    
    Parameters:
    sText - The text to search in. May be null.
    cSearch - The char to search for. May be null.
    aSortLocale - The locale to be used for case unifying.
    
    Returns:
    The first index of sSearch within sText or -1 if sSearch was not found or if any parameter was null.
    See Also:
    String.indexOf(int)
  - getIndexOfIgnoreCase
```
public static int getIndexOfIgnoreCase(@Nullable
                       String sText,
                       @Nonnegative
                       int nFromIndex,
                       char cSearch,
                       @Nonnull
                       Locale aSortLocale)
```
    Get the first index of cSearch within sText ignoring case starting at index nFromIndex.
    
    Parameters:
    sText - The text to search in. May be null.
    nFromIndex - The index to start searching in the source string
    cSearch - The char to search for. May be null.
    aSortLocale - The locale to be used for case unifying.
    
    Returns:
    The first index of sSearch within sText or -1 if sSearch was not found or if any parameter was null.
    See Also:
    String.indexOf(int)
  - getLastIndexOfIgnoreCase
```
public static int getLastIndexOfIgnoreCase(@Nullable
                           String sText,
                           char cSearch,
                           @Nonnull
                           Locale aSortLocale)
```
    Get the last index of cSearch within sText ignoring case.
    
    Parameters:
    sText - The text to search in. May be null.
    cSearch - The char to search for. May be null.
    aSortLocale - The locale to be used for case unifying.
    
    Returns:
    The last index of sSearch within sText or -1 if sSearch was not found or if any parameter was null.
    See Also:
    String.lastIndexOf(int)
  - getLastIndexOfIgnoreCase
```
public static int getLastIndexOfIgnoreCase(@Nullable
                           String sText,
                           @Nonnegative
                           int nFromIndex,
                           char cSearch,
                           @Nonnull
                           Locale aSortLocale)
```
    Get the last index of cSearch within sText ignoring case starting at index nFromIndex.
    
    Parameters:
    sText - The text to search in. May be null.
    nFromIndex - The index to start searching in the source string
    cSearch - The char to search for. May be null.
    aSortLocale - The locale to be used for case unifying.
    
    Returns:
    The last index of sSearch within sText or -1 if sSearch was not found or if any parameter was null.
    See Also:
    String.lastIndexOf(int)
  - contains
```
public static boolean contains(@Nullable
               String sText,
               @Nullable
               String sSearch)
```
    Check if sSearch is contained within sText.
    
    Parameters:
    sText - The text to search in. May be null.
    sSearch - The text to search for. May be null.
    
    Returns:
    true if sSearch is contained in sText, false otherwise.
    See Also:
    String.contains(CharSequence)
  - contains
```
public static boolean contains(@Nullable
               String sText,
               char cSearch)
```
    Check if cSearch is contained within sText.
    
    Parameters:
    sText - The text to search in. May be null.
    cSearch - The character to search for. May be null.
    
    Returns:
    true if cSearch is contained in sText, false otherwise.
    See Also:
    String.contains(CharSequence)
  - containsIgnoreCase
```
public static boolean containsIgnoreCase(@Nullable
                         String sText,
                         @Nullable
                         String sSearch,
                         @Nonnull
                         Locale aSortLocale)
```
    Check if sSearch is contained within sText ignoring case.
    
    Parameters:
    sText - The text to search in. May be null.
    sSearch - The text to search for. May be null.
    aSortLocale - The locale to be used for case unifying.
    
    Returns:
    true if sSearch is contained in sText, false otherwise.
    See Also:
    String.contains(CharSequence)
  - containsIgnoreCase
```
public static boolean containsIgnoreCase(@Nullable
                         String sText,
                         char cSearch,
                         @Nonnull
                         Locale aSortLocale)
```
    Check if cSearch is contained within sText ignoring case.
    
    Parameters:
    sText - The text to search in. May be null.
    cSearch - The char to search for. May be null.
    aSortLocale - The locale to be used for case unifying.
    
    Returns:
    true if sSearch is contained in sText, false otherwise.
    See Also:
    String.indexOf(int)
  - containsAny
```
public static boolean containsAny(@Nullable
                  char[] aInput,
                  @Nonnull
                  char[] aSearchChars)
```
    Check if any of the passed searched characters is contained in the input char array.
    
    Parameters:
    aInput - The input char array. May be null.
    aSearchChars - The char array to search. May not be null.
    
    Returns:
    true if at least any of the search char is contained in the input char array, false otherwise.
  - containsAny
```
public static boolean containsAny(@Nullable
                  String sInput,
                  @Nonnull
                  char[] aSearchChars)
```
    Check if any of the passed searched characters in contained in the input string.
    
    Parameters:
    sInput - The input string. May be null.
    aSearchChars - The char array to search. May not be null.
    
    Returns:
    true if at least any of the search char is contained in the input char array, false otherwise.
  - getOccurrenceCount
```
@Nonnegative
public static int getOccurrenceCount(@Nullable
                                 String sText,
                                 @Nullable
                                 String sSearch)
```
    Count the number of occurrences of sSearch within sText.
    
    Parameters:
    sText - The text to search in. May be null.
    sSearch - The text to search for. May be null.
    
    Returns:
    A non-negative number of occurrences.
  - getOccurrenceCountIgnoreCase
```
@Nonnegative
public static int getOccurrenceCountIgnoreCase(@Nullable
                                           String sText,
                                           @Nullable
                                           String sSearch,
                                           @Nonnull
                                           Locale aSortLocale)
```
    Count the number of occurrences of sSearch within sText ignoring case.
    
    Parameters:
    sText - The text to search in. May be null.
    sSearch - The text to search for. May be null.
    aSortLocale - The locale to be used for case unifying.
    
    Returns:
    A non-negative number of occurrences.
  - getOccurrenceCount
```
@Nonnegative
public static int getOccurrenceCount(@Nullable
                                 String sText,
                                 char cSearch)
```
    Count the number of occurrences of cSearch within sText.
    
    Parameters:
    sText - The text to search in. May be null.
    cSearch - The character to search for.
    
    Returns:
    A non-negative number of occurrences.
  - getOccurrenceCountIgnoreCase
```
@Nonnegative
public static int getOccurrenceCountIgnoreCase(@Nullable
                                           String sText,
                                           char cSearch,
                                           @Nonnull
                                           Locale aSortLocale)
```
    Count the number of occurrences of cSearch within sText ignoring case.
    
    Parameters:
    sText - The text to search in. May be null.
    cSearch - The character to search for.
    aSortLocale - The locale to be used for case unifying.
    
    Returns:
    A non-negative number of occurrences.
  - trimLeadingWhitespaces
```
@Nullable
@CheckReturnValue
public static String trimLeadingWhitespaces(@Nullable
                                                      String s)
```
    Remove any leading whitespaces from the passed string.
    
    Parameters:
    s - the String to be trimmed
    
    Returns:
    the original String with all leading whitespaces removed
  - trimTrailingWhitespaces
```
@Nullable
@CheckReturnValue
public static String trimTrailingWhitespaces(@Nullable
                                                       String s)
```
    Remove any trailing whitespaces from the passed string.
    
    Parameters:
    s - the String to be cut
    
    Returns:
    the original String with all trailing whitespaces removed
  - trimStart
```
@Nullable
@CheckReturnValue
public static String trimStart(@Nullable
                                         String sSrc,
                                         @Nullable
                                         String sLead)
```
    Trim the passed lead from the source value. If the source value does not start with the passed lead, nothing happens.
    
    Parameters:
    sSrc - The input source string
    sLead - The string to be trimmed of the beginning
    
    Returns:
    The trimmed string, or the original input string, if the lead was not found
    See Also:
    trimEnd(String, String), trimStartAndEnd(String, String), trimStartAndEnd(String, String, String)
  - trimStart
```
@Nullable
@CheckReturnValue
public static String trimStart(@Nullable
                                         String sSrc,
                                         @Nonnegative
                                         int nCount)
```
    Trim the passed lead from the source value. If the source value does not start with the passed lead, nothing happens.
    
    Parameters:
    sSrc - The input source string
    nCount - The number of characters to trim at the end.
    
    Returns:
    The trimmed string, or an empty string if nCount is ≥ the length of the source string
  - trimEnd
```
@Nullable
@CheckReturnValue
public static String trimEnd(@Nullable
                                       String sSrc,
                                       @Nullable
                                       String sTail)
```
    Trim the passed tail from the source value. If the source value does not end with the passed tail, nothing happens.
    
    Parameters:
    sSrc - The input source string
    sTail - The string to be trimmed of the end
    
    Returns:
    The trimmed string, or the original input string, if the tail was not found
    See Also:
    trimStart(String, String), trimStartAndEnd(String, String), trimStartAndEnd(String, String, String)
  - trimEnd
```
@Nullable
@CheckReturnValue
public static String trimEnd(@Nullable
                                       String sSrc,
                                       @Nonnegative
                                       int nCount)
```
    Trim the passed tail from the source value. If the source value does not end with the passed tail, nothing happens.
    
    Parameters:
    sSrc - The input source string
    nCount - The number of characters to trim at the end.
    
    Returns:
    The trimmed string, or an empty string if nCount is ≥ the length of the source string
  - trimStartAndEnd
```
@Nullable
@CheckReturnValue
public static String trimStartAndEnd(@Nullable
                                               String sSrc,
                                               @Nullable
                                               String sValueToTrim)
```
    Trim the passed lead and tail from the source value. If the source value does not start with the passed trimmed value, nothing happens.
    
    Parameters:
    sSrc - The input source string
    sValueToTrim - The string to be trimmed of the beginning and the end
    
    Returns:
    The trimmed string, or the original input string, if the value to trim was not found
    See Also:
    trimStart(String, String), trimEnd(String, String), trimStartAndEnd(String, String, String)
  - trimStartAndEnd
```
@Nullable
@CheckReturnValue
public static String trimStartAndEnd(@Nullable
                                               String sSrc,
                                               @Nullable
                                               String sLead,
                                               @Nullable
                                               String sTail)
```
    Trim the passed lead and tail from the source value. If the source value does not start with the passed lead and does not end with the passed tail, nothing happens.
    
    Parameters:
    sSrc - The input source string
    sLead - The string to be trimmed of the beginning
    sTail - The string to be trimmed of the end
    
    Returns:
    The trimmed string, or the original input string, if the lead and the tail were not found
    See Also:
    trimStart(String, String), trimEnd(String, String), trimStartAndEnd(String, String)
  - trim
```
@Nullable
@CheckReturnValue
public static String trim(@Nullable
                                    String s)
```
    Trim the passed string, if it is not null.
    
    Parameters:
    s - The string to be trimmed. May be null.
    
    Returns:
    null if the input string was null, the non-null trimmed string otherwise.
    See Also:
    String.trim()
  - getFirstChar
```
public static char getFirstChar(@Nullable
                CharSequence aCS)
```
    Get the first character of the passed character sequence
    
    Parameters:
    aCS - The source character sequence
    
    Returns:
    CGlobal.ILLEGAL_CHAR if the passed sequence was empty
  - getFirstChar
```
public static char getFirstChar(@Nullable
                char[] aChars)
```
    Get the first character of the passed array
    
    Parameters:
    aChars - The character array
    
    Returns:
    CGlobal.ILLEGAL_CHAR if the passed array was empty
  - getLastChar
```
public static char getLastChar(@Nullable
               CharSequence aCS)
```
    Get the last character of the passed character sequence
    
    Parameters:
    aCS - The source character sequence
    
    Returns:
    CGlobal.ILLEGAL_CHAR if the passed sequence was empty
  - getLastChar
```
public static char getLastChar(@Nullable
               char[] aChars)
```
    Get the last character of the passed array
    
    Parameters:
    aChars - The character array
    
    Returns:
    CGlobal.ILLEGAL_CHAR if the passed array was empty
  - getCharCount
```
@Nonnegative
public static int getCharCount(@Nullable
                           String s,
                           char cSearch)
```
  - getCharCount
```
@Nonnegative
public static int getCharCount(@Nullable
                           char[] aChars,
                           char cSearch)
```
  - getLineCount
```
@Nonnegative
public static int getLineCount(@Nullable
                           String s)
```
  - getLineCount
```
@Nonnegative
public static int getLineCount(@Nullable
                           String s,
                           char cLineSep)
```
  - getCharacterCount
```
@Nonnegative
public static int getCharacterCount(int nValue)
```
    Get the number of characters the passed value would occupy in a string representation.
    Copied from java.lang.Integer#StringSize
    
    Parameters:
    nValue - The integer value to check. May be be positive or negative.
    
    Returns:
    Number of characters required. Alyways > 0.
  - getCharacterCount
```
@Nonnegative
public static int getCharacterCount(long nValue)
```
    Get the number of characters the passed value would occupy in a string representation.
    
    Parameters:
    nValue - The long value to check. May be be positive or negative.
    
    Returns:
    Number of characters required. Always > 0.
  - getCutAfterLength
```
@Nonnull
public static String getCutAfterLength(@Nonnull
                               String sValue,
                               @Nonnegative
                               int nMaxLength)
```
  - getCutAfterLength
```
@Nonnull
public static String getCutAfterLength(@Nonnull
                               String sValue,
                               @Nonnegative
                               int nMaxLength,
                               @Nullable
                               String sNewSuffix)
```
  - replaceAllSafe
```
public static String replaceAllSafe(@Nullable
                    String sInputString,
                    @Nonnull
                    String sSearchText,
                    @Nullable
                    CharSequence aReplacementText)
```
    Same as replaceAll(String, String, CharSequence) but allowing for a null new-value, which is than interpreted as an empty string instead.
    
    Parameters:
    sInputString - The input string where the text should be replace. If this parameter is null or empty, no replacement is done.
    sSearchText - The string to be replaced. May neither be null nor empty.
    aReplacementText - The string with the replacement. May be null or empty.
    
    Returns:
    The input string as is, if the input string is empty or if the string to be replaced is not contained.
  - replaceAll
```
@Nullable
public static String replaceAll(@Nullable
                         String sInputString,
                         @Nonnull
                         String sSearchText,
                         @Nonnull
                         CharSequence aReplacementText)
```
    This is a fast replacement for String.replace(CharSequence, CharSequence). The problem with the mentioned String method is, that is uses internally regular expressions which use a synchronized block to compile the patterns. This method is inherently thread safe since String is immutable and we're operating on different temporary StringBuilder objects.
    
    Parameters:
    sInputString - The input string where the text should be replace. If this parameter is null or empty, no replacement is done.
    sSearchText - The string to be replaced. May neither be null nor empty.
    aReplacementText - The string with the replacement. May not be null but may be empty.
    
    Returns:
    The input string as is, if the input string is empty or if the search pattern and the replacement are equal or if the string to be replaced is not contained.
  - replaceAll
```
@Nullable
public static String replaceAll(@Nullable
                         String sInputString,
                         char cSearchChar,
                         char cReplacementChar)
```
    This is a fast replacement for String.replace(CharSequence, CharSequence) for characters. The problem with the mentioned String method is, that is uses internally regular expressions which use a synchronized block to compile the patterns. This method is inherently thread safe since String is immutable and we're operating on different temporary StringBuilder objects.
    
    Parameters:
    sInputString - The input string where the text should be replace. If this parameter is null or empty, no replacement is done.
    cSearchChar - The character to be replaced.
    cReplacementChar - The character with the replacement.
    
    Returns:
    The input string as is, if the input string is empty or if the search pattern and the replacement are equal or if the string to be replaced is not contained.
  - replaceAllRepeatedly
```
@Nullable
public static String replaceAllRepeatedly(@Nullable
                                   String sInputString,
                                   @Nonnull
                                   String sSearchText,
                                   @Nonnull
                                   String sReplacementText)
```
    Just calls replaceAll as long as there are still replacements found
    
    Parameters:
    sInputString - The input string where the text should be replace. If this parameter is null or empty, no replacement is done.
    sSearchText - The string to be replaced. May neither be null nor empty.
    sReplacementText - The string with the replacement. May not be null but may be empty.
    
    Returns:
    The input string as is, if the input string is empty or if the string to be replaced is not contained.
  - getReplaceMultipleResultLength
```
public static int getReplaceMultipleResultLength(@Nonnull
                                 char[] aInputString,
                                 @Nonnull@Nonempty
                                 char[] aSearchChars,
                                 @Nonnull@Nonempty
                                 char[][] aReplacementStrings)
```
    Get the result length (in characters) when replacing all patterns with the replacements on the passed input array.
    
    Parameters:
    aInputString - Input char array. May not be null.
    aSearchChars - The one-character search patterns. May not be null.
    aReplacementStrings - The replacements to be performed. May not be null. The first dimension of this array must have exactly the same amount of elements as the patterns parameter array.
    
    Returns:
    CGlobal.ILLEGAL_UINT if no replacement was needed, and therefore the length of the input array could be used.
  - replaceMultiple
```
@Nonnull
public static char[] replaceMultiple(@Nullable
                             String sInputString,
                             @Nonnull
                             char[] aSearchChars,
                             @Nonnull
                             char[][] aReplacementStrings)
```
    Optimized replace method that replaces a set of characters with a set of strings. This method was created for efficient XML special character replacements!
    
    Parameters:
    sInputString - The input string.
    aSearchChars - The characters to replace.
    aReplacementStrings - The new strings to be inserted instead. Must have the same array length as aPatterns.
    
    Returns:
    The replaced version of the string or an empty char array if the input string was null.
  - replaceMultiple
```
@Nonnull
public static char[] replaceMultiple(@Nullable
                             char[] aInput,
                             @Nonnull
                             char[] aSearchChars,
                             @Nonnull
                             char[][] aReplacementStrings)
```
    Optimized replace method that replaces a set of characters with a set of strings. This method was created for efficient XML special character replacements!
    
    Parameters:
    aInput - The input string.
    aSearchChars - The characters to replace.
    aReplacementStrings - The new strings to be inserted instead. Must have the same array length as aPatterns.
    
    Returns:
    The replaced version of the string or an empty char array if the input string was null.
  - replaceMultipleTo
```
@Nonnegative
public static int replaceMultipleTo(@Nullable
                                String sInputString,
                                @Nonnull
                                char[] aSearchChars,
                                @Nonnull
                                char[][] aReplacementStrings,
                                @Nonnull
                                Writer aTarget)
                             throws IOException
```
    Specialized version of replaceMultiple(String, char[], char[][]) where the object where the output should be appended is passed in as a parameter. This has the advantage, that not length calculation needs to take place!
    
    Parameters:
    sInputString - The input string.
    aSearchChars - The characters to replace.
    aReplacementStrings - The new strings to be inserted instead. Must have the same array length as aPatterns.
    aTarget - Where the replaced objects should be written to. May not be null.
    
    Returns:
    The number of replacements performed. Always ≥ 0.
    
    Throws:
    
    IOException - In case writing to the Writer fails
  - replaceMultipleTo
```
@Nonnegative
public static int replaceMultipleTo(@Nullable
                                char[] aInput,
                                @Nonnull
                                char[] aSearchChars,
                                @Nonnull
                                char[][] aReplacementStrings,
                                @Nonnull
                                Writer aTarget)
                             throws IOException
```
    Specialized version of replaceMultiple(String, char[], char[][]) where the object where the output should be appended is passed in as a parameter. This has the advantage, that not length calculation needs to take place!
    
    Parameters:
    aInput - The input string.
    aSearchChars - The characters to replace.
    aReplacementStrings - The new strings to be inserted instead. Must have the same array length as aPatterns.
    aTarget - Where the replaced objects should be written to. May not be null.
    
    Returns:
    The number of replacements performed. Always ≥ 0.
    
    Throws:
    
    IOException - In case writing to the Writer fails
  - replaceMultiple
```
@Nonnull
public static char[] replaceMultiple(@Nullable
                             String sInputString,
                             @Nonnull
                             char[] aSearchChars,
                             char cReplacementChar)
```
    Optimized replace method that replaces a set of characters with another character. This method was created for efficient unsafe character replacements!
    
    Parameters:
    sInputString - The input string.
    aSearchChars - The characters to replace.
    cReplacementChar - The new char to be used instead of the search chars.
    
    Returns:
    The replaced version of the string or an empty char array if the input string was null.
  - replaceMultiple
```
@Nullable
public static String replaceMultiple(@Nullable
                              String sInputString,
                              @Nullable
                              Map<String,String> aTransTable)
```
    Perform all string replacements on the input string as defined by the passed map. All replacements are done using replaceAll(String,String,CharSequence) which is ok.
    
    Parameters:
    sInputString - The input string where the text should be replaced. May be null.
    aTransTable - The map with the replacements to execute. If null is passed, the input string is not altered.
    
    Returns:
    null if the input string was null.
  - replaceMultiple
```
@Nullable
public static String replaceMultiple(@Nullable
                              String sInputString,
                              @Nullable
                              String[] aSearchTexts,
                              @Nullable
                              String[] aReplacementTexts)
```
    Perform all string replacements on the input string as defined by the passed map. All replacements are done using replaceAll(String,String,CharSequence) which is ok.
    
    Parameters:
    sInputString - The input string where the text should be replaced. May be null.
    aSearchTexts - The texts to be searched. If null is passed, the input string is not altered.
    aReplacementTexts - The texts to be used as the replacements. This array must have exactly the same number of elements than the searched texts! If null is passed, the input string is not altered.
    
    Returns:
    null if the input string was null. The unmodified input string if no search/replace patterns where provided.
  - removeAll
```
@Nullable
public static String removeAll(@Nullable
                        String sInputString,
                        char cRemoveChar)
```
    Remove all occurrences of the passed character from the specified input string
    
    Parameters:
    sInputString - The input string where the character should be removed. If this parameter is null or empty, no removing is done.
    cRemoveChar - The character to be removed.
    
    Returns:
    The input string as is, if the input string is empty or if the remove char is not contained.
  - getLength
```
@Nonnegative
public static int getLength(@Nullable
                        CharSequence aCS)
```
    Get the length of the passed character sequence.
    
    Parameters:
    aCS - The character sequence who's length is to be determined. May be null.
    
    Returns:
    0 if the parameter is null, its length otherwise.
    See Also:
    CharSequence.length()
  - getNotNull
```
@Nonnull
public static String getNotNull(@Nullable
                        String s)
```
    Get the passed string but never return null. If the passed parameter is null an empty string is returned.
    
    Parameters:
    s - The parameter to be not null.
    
    Returns:
    An empty string if the passed parameter is null, the passed string otherwise.
  - getNotNull
```
@Nullable
public static String getNotNull(@Nullable
                         String s,
                         String sDefaultIfNull)
```
    Get the passed string but never return null. If the passed parameter is null the second parameter is returned.
    
    Parameters:
    s - The parameter to be not null.
    sDefaultIfNull - The value to be used of the first parameter is null. May be null but in this case the call to this method is obsolete.
    
    Returns:
    The passed default value if the string is null, otherwise the input string.
  - getNotNull
```
@Nonnull
public static CharSequence getNotNull(@Nullable
                              CharSequence s)
```
    Get the passed CharSequence but never return null. If the passed parameter is null an empty string is returned.
    
    Parameters:
    s - The parameter to be not null.
    
    Returns:
    An empty string if the passed parameter is null, the passed CharSequence otherwise.
  - getNotNull
```
@Nullable
public static CharSequence getNotNull(@Nullable
                               CharSequence s,
                               CharSequence sDefaultIfNull)
```
    Get the passed CharSequence but never return null. If the passed parameter is null the second parameter is returned.
    
    Parameters:
    s - The parameter to be not null.
    sDefaultIfNull - The value to be used of the first parameter is null. May be null but in this case the call to this method is obsolete.
    
    Returns:
    The passed default value if the string is null, otherwise the input CharSequence.
  - getToString
```
@Nonnull
public static String getToString(@Nullable
                         Object aObject)
```
    Convert the passed object to a string using the Object.toString() method.
    
    Parameters:
    aObject - The value to be converted. May be null.
    
    Returns:
    An empty string in case the passed object was null. Never null.
    See Also:
    Object.toString()
  - getToString
```
@Nullable
public static String getToString(@Nullable
                          Object aObject,
                          @Nullable
                          String sNullValue)
```
    Convert the passed object to a string using the Object.toString() method or otherwise return the passed default value.
    
    Parameters:
    aObject - The value to be converted. May be null.
    sNullValue - The value to be returned in case the passed object is null. May be null itself.
    
    Returns:
    The passed default value in case the passed object was null or the result of Object.toString() on the passed object.
    See Also:
    Object.toString()
  - getWithoutLeadingChar
```
@Nonnull
public static String getWithoutLeadingChar(@Nullable
                                   String sStr)
```
    Get the passed string without the first char.
    
    Parameters:
    sStr - The source string. May be null.
    
    Returns:
    An empty, non-null string if the passed string has a length ≤ 1.
  - getWithoutLeadingChars
```
@Nonnull
public static String getWithoutLeadingChars(@Nullable
                                    String sStr,
                                    @Nonnegative
                                    int nCount)
```
    Get the passed string without the specified number of leading chars.
    
    Parameters:
    sStr - The source string. May be null.
    nCount - The number of chars to remove.
    
    Returns:
    An empty, non-null string if the passed string has a length ≤ nCount.
  - getWithoutTrailingChar
```
@Nonnull
public static String getWithoutTrailingChar(@Nullable
                                    String sStr)
```
    Get the passed string without the last char.
    
    Parameters:
    sStr - The source string. May be null.
    
    Returns:
    An empty, non-null string if the passed string has a length ≤ 1.
  - getWithoutTrailingChars
```
@Nonnull
public static String getWithoutTrailingChars(@Nullable
                                     String sStr,
                                     @Nonnegative
                                     int nCount)
```
    Get the passed string without the specified number of trailing chars.
    
    Parameters:
    sStr - The source string. May be null.
    nCount - The number of chars to remove.
    
    Returns:
    An empty, non-null string if the passed string has a length ≤ nCount.
  - getWithoutAnySpaces
```
@Nonnull
public static String getWithoutAnySpaces(@Nullable
                                 String sStr)
```
    Get the passed string where all spaces (white spaces or unicode spaces) have been removed.
    
    Parameters:
    sStr - The source string. May be null
    
    Returns:
    A non-null string representing the passed string without any spaces
  - getUntilFirstIncl
```
@Nullable
public static String getUntilFirstIncl(@Nullable
                                String sStr,
                                char cSearch)
```
    Get everything from the string up to and including the first passed char.
    
    Parameters:
    sStr - The source string. May be null.
    cSearch - The character to search.
    
    Returns:
    null if the passed string does not contain the search character.
  - getUntilFirstExcl
```
@Nullable
public static String getUntilFirstExcl(@Nullable
                                String sStr,
                                char cSearch)
```
    Get everything from the string up to and excluding first the passed char.
    
    Parameters:
    sStr - The source string. May be null.
    cSearch - The character to search.
    
    Returns:
    null if the passed string does not contain the search character.
  - getUntilFirstIncl
```
@Nullable
public static String getUntilFirstIncl(@Nullable
                                String sStr,
                                @Nullable
                                String sSearch)
```
    Get everything from the string up to and including the first passed string.
    
    Parameters:
    sStr - The source string. May be null.
    sSearch - The string to search. May be null.
    
    Returns:
    null if the passed string does not contain the search string. If the search string is empty, the empty string is returned.
  - getUntilFirstExcl
```
@Nullable
public static String getUntilFirstExcl(@Nullable
                                String sStr,
                                @Nullable
                                String sSearch)
```
    Get everything from the string up to and excluding the first passed string.
    
    Parameters:
    sStr - The source string. May be null.
    sSearch - The string to search. May be null.
    
    Returns:
    null if the passed string does not contain the search string. If the search string is empty, the empty string is returned.
  - getUntilLastIncl
```
@Nullable
public static String getUntilLastIncl(@Nullable
                               String sStr,
                               char cSearch)
```
    Get everything from the string up to and including the first passed char.
    
    Parameters:
    sStr - The source string. May be null.
    cSearch - The character to search.
    
    Returns:
    null if the passed string does not contain the search character.
  - getUntilLastExcl
```
@Nullable
public static String getUntilLastExcl(@Nullable
                               String sStr,
                               char cSearch)
```
    Get everything from the string up to and excluding first the passed char.
    
    Parameters:
    sStr - The source string. May be null.
    cSearch - The character to search.
    
    Returns:
    null if the passed string does not contain the search character.
  - getUntilLastIncl
```
@Nullable
public static String getUntilLastIncl(@Nullable
                               String sStr,
                               @Nullable
                               String sSearch)
```
    Get everything from the string up to and including the first passed string.
    
    Parameters:
    sStr - The source string. May be null.
    sSearch - The string to search. May be null.
    
    Returns:
    null if the passed string does not contain the search string. If the search string is empty, the empty string is returned.
  - getUntilLastExcl
```
@Nullable
public static String getUntilLastExcl(@Nullable
                               String sStr,
                               @Nullable
                               String sSearch)
```
    Get everything from the string up to and excluding the first passed string.
    
    Parameters:
    sStr - The source string. May be null.
    sSearch - The string to search. May be null.
    
    Returns:
    null if the passed string does not contain the search string. If the search string is empty, the empty string is returned.
  - getFromFirstIncl
```
@Nullable
public static String getFromFirstIncl(@Nullable
                               String sStr,
                               char cSearch)
```
    Get everything from the string from and including the first passed char.
    
    Parameters:
    sStr - The source string. May be null.
    cSearch - The character to search.
    
    Returns:
    null if the passed string does not contain the search character.
  - getFromFirstExcl
```
@Nullable
public static String getFromFirstExcl(@Nullable
                               String sStr,
                               char cSearch)
```
    Get everything from the string from and excluding the first passed char.
    
    Parameters:
    sStr - The source string. May be null.
    cSearch - The character to search.
    
    Returns:
    null if the passed string does not contain the search character.
  - getFromFirstIncl
```
@Nullable
public static String getFromFirstIncl(@Nullable
                               String sStr,
                               @Nullable
                               String sSearch)
```
    Get everything from the string from and including the passed string.
    
    Parameters:
    sStr - The source string. May be null.
    sSearch - The string to search. May be null.
    
    Returns:
    null if the passed string does not contain the search string. If the search string is empty, the input string is returned unmodified.
  - getFromFirstExcl
```
@Nullable
public static String getFromFirstExcl(@Nullable
                               String sStr,
                               @Nullable
                               String sSearch)
```
    Get everything from the string from and excluding the passed string.
    
    Parameters:
    sStr - The source string. May be null.
    sSearch - The string to search. May be null.
    
    Returns:
    null if the passed string does not contain the search string. If the search string is empty, the input string is returned unmodified.
  - getFromLastIncl
```
@Nullable
public static String getFromLastIncl(@Nullable
                              String sStr,
                              char cSearch)
```
    Get everything from the string from and including the first passed char.
    
    Parameters:
    sStr - The source string. May be null.
    cSearch - The character to search.
    
    Returns:
    null if the passed string does not contain the search character.
  - getFromLastExcl
```
@Nullable
public static String getFromLastExcl(@Nullable
                              String sStr,
                              char cSearch)
```
    Get everything from the string from and excluding the first passed char.
    
    Parameters:
    sStr - The source string. May be null.
    cSearch - The character to search.
    
    Returns:
    null if the passed string does not contain the search character.
  - getFromLastIncl
```
@Nullable
public static String getFromLastIncl(@Nullable
                              String sStr,
                              @Nullable
                              String sSearch)
```
    Get everything from the string from and including the passed string.
    
    Parameters:
    sStr - The source string. May be null.
    sSearch - The string to search. May be null.
    
    Returns:
    null if the passed string does not contain the search string. If the search string is empty, the input string is returned unmodified.
  - getFromLastExcl
```
@Nullable
public static String getFromLastExcl(@Nullable
                              String sStr,
                              @Nullable
                              String sSearch)
```
    Get everything from the string from and excluding the passed string.
    
    Parameters:
    sStr - The source string. May be null.
    sSearch - The string to search. May be null.
    
    Returns:
    null if the passed string does not contain the search string. If the search string is empty, the input string is returned unmodified.
  - getFirstToken
```
@Nullable
public static String getFirstToken(@Nullable
                            String sStr,
                            char cSearch)
```
    Get the first token up to (and excluding) the separating character.
    
    Parameters:
    sStr - The string to search. May be null.
    cSearch - The search character.
    
    Returns:
    The passed string if no such separator token was found.
  - getFirstToken
```
@Nullable
public static String getFirstToken(@Nullable
                            String sStr,
                            @Nullable
                            String sSearch)
```
    Get the first token up to (and excluding) the separating string.
    
    Parameters:
    sStr - The string to search. May be null.
    sSearch - The search string. May be null.
    
    Returns:
    The passed string if no such separator token was found.
  - getLastToken
```
@Nullable
public static String getLastToken(@Nullable
                           String sStr,
                           char cSearch)
```
    Get the last token from (and excluding) the separating character.
    
    Parameters:
    sStr - The string to search. May be null.
    cSearch - The search character.
    
    Returns:
    The passed string if no such separator token was found.
  - getLastToken
```
@Nullable
public static String getLastToken(@Nullable
                           String sStr,
                           @Nullable
                           String sSearch)
```
    Get the last token from (and excluding) the separating string.
    
    Parameters:
    sStr - The string to search. May be null.
    sSearch - The search string. May be null.
    
    Returns:
    The passed string if no such separator token was found.
  - getReverse
```
@Nullable
public static String getReverse(@Nullable
                         String sStr)
```
  - removeMultiple
```
@Nonnull
public static String removeMultiple(@Nullable
                            String sInputString,
                            @Nonnull
                            char[] aRemoveChars)
```
    Optimized remove method that removes a set of characters from an input string!
    
    Parameters:
    sInputString - The input string.
    aRemoveChars - The characters to remove. May not be null.
    
    Returns:
    The version of the string without the passed characters or an empty String if the input string was null.

Class StringHelper

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

STRING_NOT_FOUND

Method Detail

hasNoText

hasNoText

isEmpty

isEmpty

hasNoTextAfterTrim

isEmptyAfterTrim

hasText

hasText

isNotEmpty

isNotEmpty

hasTextAfterTrim

isNotEmptyAfterTrim

isAllWhitespace

getLeadingZero

getLeadingZero

getLeadingZero

getLeadingZero

getLeadingZero

getLeadingZero

getLeadingZero

getWithLeading

getHexChar

getHexCharUpperCase

getHexEncoded

getHexEncoded

getHexEncoded

getHexValue

getHexByte

getHexDecoded

getHexDecoded

getHexDecoded

getHexString

getHexStringLeadingZero

getHexStringLeadingZero2

getHexString

getHexStringLeadingZero

getHexString

getHexStringLeadingZero

getHexString

getHexStringLeadingZero

getLeadingWhitespaceCount

getTrailingWhitespaceCount

getLeadingCharCount

getTrailingCharCount

getImploded

getImploded

getImploded

getImploded

getImploded

getImploded

getImploded

getImploded

getImploded

getImploded

getImploded

getImplodedNonEmpty

getImplodedNonEmpty

getImplodedNonEmpty

getImplodedNonEmpty

getImplodedNonEmpty

getImplodedNonEmpty

getImplodedNonEmpty

getExplodedArray

getExplodedArray

getExploded

getExploded

getExploded

getExploded

getExploded

getExploded

getExplodedToSet

getExplodedToOrderedSet

getExplodedToSortedSet