StringUtil (commons-lang 1.2.13-SNAPSHOT API)

java.lang.Object
- de.unkrig.commons.lang.StringUtil

```
public final class StringUtil
extends Object
```
Various java.lang.String-related utility methods.

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class StringUtil.AbstractIndexOf

static interface StringUtil.IndexOf

Nested Classes
Modifier and Type	Class and Description
`static class`	`StringUtil.AbstractIndexOf`
`static interface`	`StringUtil.IndexOf`

Field Summary

Fields
Modifier and Type Field and Description

static Predicate<CharSequence> IS_BLANK
A predicate that evaluates its subject with isBlank(CharSequence).

Fields
Modifier and Type	Field and Description
`static Predicate<CharSequence>`	`IS_BLANK` A predicate that evaluates its subject with `isBlank(CharSequence)`.

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static Iterable<Character>`	`asIterable(CharSequence subject)` Wraps a char sequence as an iterable.
`static StringUtil.IndexOf`	`boyerMooreHorspoolIndexOf(char[][] needle)` Implementation of the Boyer-Moore-Horspool string search algorithm.
`static StringUtil.IndexOf`	`boyerMooreHorspoolIndexOf(CharSequence needle)` Implementation of the Boyer-Moore-Horspool string search algorithm.
`static int`	`compareTo(CharSequence cs1, CharSequence cs2)` Naturally, `CharSequence` does not extend `Comparable`.
`static boolean`	`containsAny(String subject, String characters)`
`static boolean`	`equals(CharSequence cs1, CharSequence cs2)` Naturally, `CharSequence` does not refine `Object.equals(Object)`.
`static boolean`	`equalsIgnoreCase(String s1, String s2)`
`static String`	`firstLetterToLowerCase(String s)`
`static String`	`firstLetterToUpperCase(String s)`
`static StringUtil.IndexOf`	`indexOf(char[] needle)` Runtime-optimized reimplementation of `String.indexOf(String)` and `String.lastIndexOf(String)`.
`static StringUtil.IndexOf`	`indexOf(char[][] needle)` Creates a highly optimized `StringUtil.IndexOf` object that searches for "multivalent" `needle`.
`static StringUtil.IndexOf`	`indexOf(CharSequence needle)` Runtime-optimized reimplementation of `String.indexOf(String)` and `String.lastIndexOf(String)`.
`static boolean`	`isBlank(CharSequence cs)`
`static Iterator<Character>`	`iterator(CharSequence subject)` Returns an iterator that produces the characters of the `subject`, from index 0 through index `subject.length() - 1`.
`static String`	`join(Collection<? extends Object> elements, String glue)` Converts all `elements` to string and concatenates these, separated by the `glue`.
`static String`	`lessTrailingLineSeparators(String s)`
`static StringUtil.IndexOf`	`naiveIndexOf(CharSequence needle)`
`static String`	`repeat(int n, char c)`
`static String`	`repeat(int n, char[] chars)`
`static String`	`repeat(int n, CharSequence cs)`
`static Iterator<Character>`	`reverseIterator(CharSequence subject)` Returns an iterator that produces the characters of the `subject` in reverse order, from index `subject.length() - 1` through index 0.

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

- Field Detail
  - IS_BLANK
```
public static final Predicate<CharSequence> IS_BLANK
```
    A predicate that evaluates its subject with isBlank(CharSequence).
- Method Detail
  - join
```
public static String join(Collection<? extends Object> elements,
                          String glue)
```
    Converts all elements to string and concatenates these, separated by the glue.
  - equals
```
public static boolean equals(CharSequence cs1,
                             CharSequence cs2)
```
    Naturally, CharSequence does not refine Object.equals(Object). This method fills the gap.
  - compareTo
```
public static int compareTo(CharSequence cs1,
                            CharSequence cs2)
```
    Naturally, CharSequence does not extend Comparable. This method fills the gap.
  - repeat
```
public static String repeat(int n,
                            char c)
```
    Returns:
    
    A string consisting of n times the character c
  - repeat
```
public static String repeat(int n,
                            char[] chars)
```
    Returns:
    
    A string consisting of n times the character sequence chars
  - repeat
```
public static String repeat(int n,
                            CharSequence cs)
```
    Returns:
    
    A string consisting of n times the cs
  - isBlank
```
public static boolean isBlank(CharSequence cs)
```
    Returns:
    
    Whether the given char sequences consists only of characters 0...32
  - firstLetterToUpperCase
```
public static String firstLetterToUpperCase(String s)
```
    Returns:
    
    The string s, with the first letter converted to upper case
  - firstLetterToLowerCase
```
public static String firstLetterToLowerCase(String s)
```
    Returns:
    
    The string s, with the first letter converted to lower case
  - asIterable
```
public static Iterable<Character> asIterable(CharSequence subject)
```
    Wraps a char sequence as an iterable.
  - iterator
```
public static Iterator<Character> iterator(CharSequence subject)
```
    Returns an iterator that produces the characters of the subject, from index 0 through index subject.length() - 1.
  - reverseIterator
```
public static Iterator<Character> reverseIterator(CharSequence subject)
```
    Returns an iterator that produces the characters of the subject in reverse order, from index subject.length() - 1 through index 0.
  - lessTrailingLineSeparators
```
public static String lessTrailingLineSeparators(String s)
```
    Returns:
    
    The s, with all trailing '\r' and '\n' chopped off
    
    See Also:
    
    BufferedReader.readLine()
  - containsAny
```
public static boolean containsAny(String subject,
                                  String characters)
```
    Returns:
    
    Whether the subject contains any of the characters
  - equalsIgnoreCase
```
public static boolean equalsIgnoreCase(@Nullable
                                       String s1,
                                       @Nullable
                                       String s2)
```
    See Also:
    
    ObjectUtil.equals(Object, Object)
  - indexOf
```
public static StringUtil.IndexOf indexOf(char[] needle)
```
    Runtime-optimized reimplementation of String.indexOf(String) and String.lastIndexOf(String).
    This method returns an implementation that performs at least as well as the String methods by analyzing the needle (the string to search for).
    
    Parameters:
    
    needle - The string to search for
  - indexOf
```
public static StringUtil.IndexOf indexOf(CharSequence needle)
```
    Runtime-optimized reimplementation of String.indexOf(String) and String.lastIndexOf(String).
    This method returns an implementation that performs at least as well as the String methods by analyzing the needle (the string to search for).
    
    Parameters:
    
    needle - The string to search for
  - naiveIndexOf
```
public static StringUtil.IndexOf naiveIndexOf(CharSequence needle)
```
    Returns:
    
    A wrapper for String.indexOf(String) and String.lastIndexOf(String), which implements a naive string search algorithm
  - boyerMooreHorspoolIndexOf
```
public static StringUtil.IndexOf boyerMooreHorspoolIndexOf(CharSequence needle)
```
    Implementation of the Boyer-Moore-Horspool string search algorithm.
    
    Parameters:
    
    needle - The string to search for
    
    See Also:
    
    The Boyer–Moore–Horspool algorithm
  - indexOf
```
public static StringUtil.IndexOf indexOf(char[][] needle)
```
    Creates a highly optimized StringUtil.IndexOf object that searches for "multivalent" needle. Multivalent means that a character in the haystack equals any of needle[offset].
    E.g. a case-insensitive search for "abc" in the haystack string could be implemented like this:
```
   int idx = StringUtil.indexOf(new char[][] { { 'a', 'A' }, { 'b', 'B' }, { 'c', 'C' } }).indexOf(haystack);
 
```
  - boyerMooreHorspoolIndexOf
```
public static StringUtil.IndexOf boyerMooreHorspoolIndexOf(char[][] needle)
```
    Implementation of the Boyer-Moore-Horspool string search algorithm.
    Notice that the indexOf(char[][]) method performs some extra optimizations, e.g. when the needle is actually univalent (all of needle[n].length are 1), or when the needle is very short.
    
    See Also:
    
    The Boyer–Moore–Horspool algorithm

Class StringUtil

Nested Class Summary

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

IS_BLANK

Method Detail

join

equals

compareTo

repeat

repeat

repeat

isBlank

firstLetterToUpperCase

firstLetterToLowerCase

asIterable

iterator

reverseIterator

lessTrailingLineSeparators

containsAny

equalsIgnoreCase

indexOf

indexOf

naiveIndexOf

boyerMooreHorspoolIndexOf

indexOf

boyerMooreHorspoolIndexOf