XChars (MicroStream API)

java.lang.Object
- one.microstream.chars.XChars

```
public final class XChars
extends Object
```
Static util class with character operation algorithms missing in or significantly superior to those in JDK.

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static VarString`	`addSystemString(Object instance, VarString vs)`
`static char[]`	`append(char[] string, char c)`
`static char[]`	`append(char[] a, char[] b)`
`static char[]`	`append(char c, char[] string)`
`static VarString`	`appendArraySeperated(VarString vc, char separator, Object... elements)`
`static VarString`	`appendArraySeperated(VarString vs, String separator, Object... elements)`
`static boolean`	`applies(CharSequence chars, _charPredicate predicate)`
`static boolean`	`applies(CharSequence chars, int startIndex, _charPredicate predicate)`
`static VarString`	`assembleCautiously(VarString vs, Object object)` Assembles the passed instance "cautiously" in the sense that only types recognizable via `XTypes.isValueType(Object)` get assembled using their `Object.toString()` method, while all others are assembled using `systemString(Object)` (which behaves identical to the actual implementation of `Object.toString()`).
`static VarString`	`assembleNewLinedTabbed(VarString vs, CharSequence... elements)`
`static VarString`	`assembleSeparated(VarString vs, char separator, CharSequence... elements)`
`static String`	`asString(char... chars)`
`static String`	`asString(char c)` This method does intentionally not use the pseudo-constructor naming pattern since it does not create new instances of `String`.
`static int`	`commonPrefixLength(char[] a, char[] b)`
`static int`	`commonSubstringLength(char[] a, char[] b)`
`static int`	`commonSuffixLength(char[] a, char[] b)`
`static char[]`	`concat(char[]... arrays)`
`static String`	`concat(char separator, Object... parts)`
`static boolean`	`contains(char[] data, char c)`
`static boolean`	`contains(char[] data, int dataOffset, int dataLength, char c)`
`static boolean`	`contains(char[] subject, int subjectOffset, int subjectLength, char[] sample, int sampleOffset, int sampleLength)`
`static boolean`	`contains(String[] strings, String subject)`
`static boolean`	`contains(String s, char c)`
`static String`	`convertUnderscoresToCamelCase(String parameterName)`
`static VarString`	`convertUnderscoresToCamelCase(VarString vs, String s)`
`static int`	`count(char[] input, int startIndex, int boundIndex, char c)`
`static int`	`count(char[] data, int dataOffset, int dataCount, char[] subject, int subjectOffset, int subjectCount)`
`static int`	`countCharacter(String data, char c)`
`static int`	`countCodePoint(String data, int codePoint)`
`static String`	`createMedialCapitalsString(String... elements)`
`static Charset`	`defaultJvmCharset()` Alias for `Charset.defaultCharset()`, which returns sometimes the one thing and sometimes another.
`static String`	`ensureCharAtEnd(String s, char c)`
`static boolean`	`equals(char[] chars1, int offset1, char[] chars2, int offset2, int length)`
`static boolean`	`equals(String string, char[] chars, int offset)`
`static String`	`escapeChar(char c)`
`static VarString`	`escapeChar(VarString vc, char c)`
`static boolean`	`hasContent(CharSequence s)`
`static boolean`	`hasContent(String s)`
`static int`	`hashCode(char[] chars, int offset, int length)` This method rebuilds the `String` hashing algorithm.
`static boolean`	`hasNoContent(CharSequence s)`
`static boolean`	`hasNoContent(String s)`
`static int`	`indexOf(char[] data, char c)`
`static int`	`indexOf(char[] data, int dataLength, char[] subject)`
`static int`	`indexOf(char[] source, int sourceCount, char[] target, int targetCount, int fromIndex)`
`static int`	`indexOf(char[] data, int offset, int length, char c)`
`static int`	`indexOf(char[] data, int dataOffset, int dataLength, char[] chars)`
`static int`	`indexOf(char[] source, int sourceOffset, int sourceCount, char[] target, int targetOffset, int targetCount, int fromIndex)`
`static long`	`internalParse_longLiteral(char[] input, int offset, int length)` Specialcase higher performance implementation of decimal integer literal parsing.
`static boolean`	`intersects(char[] chars1, char[] chars2)` Returns `true` if the two given character arrays have at least one character in common.
`static boolean`	`isDigit(char c)`
`static boolean`	`isEmpty(CharSequence cs)`
`static boolean`	`isEqual(String s1, String s2)`
`static boolean`	`isEqualIgnoreCase(String s1, String s2)`
`static boolean`	`isNonWhitespace(char c)`
`static boolean`	`isWhitespace(char c)`
`static void`	`iterate(char[] chars, _charProcedure iterator)`
`static void`	`iterate(char[] chars, int offset, int length, _charProcedure iterator)`
`static void`	`iterate(CharSequence chars, _charProcedure iterator)`
`static void`	`iterate(String chars, _charProcedure iterator)`
`static char[]`	`longestCommonPrefix(char[] a, char[] b)`
`static String`	`longestCommonPrefix(String a, String b)`
`static int`	`longestCommonPrefixLength(String a, String b)`
`static char[]`	`longestCommonSubstring(char[] a, char[] b)`
`static String`	`longestCommonSubstring(String a, String b)`
`static int`	`longestCommonSubstringLength(String a, String b)`
`static char[]`	`longestCommonSuffix(char[] a, char[] b)`
`static String`	`longestCommonSuffix(String a, String b)`
`static int`	`longestCommonSuffixLength(String a, String b)`
`static String`	`lowerCaseFirstChar(String s)`
`static String`	`mathRangeExcExc(double lowerBound, double upperBound)`
`static String`	`mathRangeExcExc(long lowerBound, long upperBound)`
`static String`	`mathRangeExcExc(String lowerBound, String upperBound)`
`static String`	`mathRangeExcInc(double lowerBound, double maximum)`
`static String`	`mathRangeExcInc(long lowerBound, long maximum)`
`static String`	`mathRangeExcInc(String lowerBound, String maximum)`
`static String`	`mathRangeIncExc(double minimum, double upperBound)`
`static String`	`mathRangeIncExc(long minimum, long upperBound)`
`static String`	`mathRangeIncExc(String minimum, String upperBound)`
`static String`	`mathRangeIncInc(double minimum, double maximum)`
`static String`	`mathRangeIncInc(long minimum, long maximum)`
`static String`	`mathRangeIncInc(String minimum, String maximum)`
`static int`	`maxCharCount_boolean()`
`static int`	`maxCharCount_byte()`
`static int`	`maxCharCount_char()`
`static int`	`maxCharCount_double()`
`static int`	`maxCharCount_float()`
`static int`	`maxCharCount_int()`
`static int`	`maxCharCount_long()`
`static int`	`maxCharCount_short()`
`static String`	`nonNullString(Object object)`
`static <C extends CharSequence> C`	`notEmpty(C charSequence)`
`static String`	`padLeft(String s, int totalLength)`
`static String`	`padLeft(String s, int totalLength, char paddingChar)`
`static String`	`padLeft0(String s, int totalLength)`
`static String`	`padRight(String s, int totalLength)`
`static String`	`padRight(String s, int totalLength, char paddingChar)`
`static String`	`padRight0(String s, int totalLength)`
`static String`	`padSpace(String s, int chars)`
`static byte`	`parse_byteDecimal(char[] input)`
`static byte`	`parse_byteDecimal(char[] input, int offset, int length)`
`static double`	`parse_double(char[] input, int offset, int length)`
`static float`	`parse_float(char[] input, int offset, int length)`
`static int`	`parse_intLiteral(char[] input)`
`static int`	`parse_intLiteral(char[] input, int offset, int length)`
`static long`	`parse_longDecimal(char[] input)`
`static long`	`parse_longDecimal(char[] input, int offset, int length)`
`static short`	`parse_shortDecimal(char[] input)`
`static short`	`parse_shortDecimal(char[] input, int offset, int length)`
`static char`	`parseChar(String s)` Parses the char escape sequence Strings "\n" etc.
`static int[]`	`parseTo_intArray(String... intStrings)`
`static Integer[]`	`parseToIntegerArray(String... intStrings)`
`static int`	`put(boolean value, char[] target, int offset)`
`static int`	`put(byte value, char[] target, int offset)`
`static int`	`put(char[] value, char[] target, int offset)`
`static int`	`put(double value, char[] target, int offset)`
`static int`	`put(float value, char[] target, int offset)`
`static int`	`put(int value, char[] target, int offset)`
`static int`	`put(long value, char[] target, int offset)`
`static int`	`put(short value, char[] target, int offset)`
`static int`	`put(String s, char[] target, int offset)`
`static int`	`putFalse(char[] target, int offset)`
`static int`	`putHexDec(byte value, char[] target, int offset)`
`static int`	`putNull(char[] target, int offset)`
`static int`	`putTrue(char[] target, int offset)`
`static char`	`randomReadable_char()`
`static VarByte`	`readAllBytesFromInputStream(InputStream inputStream)`
`static VarByte`	`readAllBytesFromInputStream(VarByte bytes, InputStream inputStream)`
`static char[]`	`readChars(String s)`
`static String`	`readStringFromInputStream(InputStream inputStream, Charset charset)`
`static int`	`replaceFirst(char[] chars, int offset, int length, char sample, char replacement)`
`static int`	`shortStringLength()` Arbitrary threshold of 1000 to discrimate "short" strings from "long" strings. The rationale behind that is that "short" strings usually allow for simpler and faster algorithms, which become inefficient on larger strings.
`static <C extends Consumer<String>> C`	`splitAndTrimToStrings(char[] input, char separator, C collector)` High-performance implementation of the very common case to split a character sequence by a single character and trim all elements.
`static <C extends Consumer<String>> C`	`splitAndTrimToStrings(String input, char separator, C collector)` High-performance implementation of the very common case to split a string by a single character and trim all elements.
`static String[]`	`splitSimple(String s, String separator)`
`static <C extends Consumer<? super String>> C`	`splitSimple(String s, String separator, C collector)`
`static Charset`	`standardCharset()` Returns `StandardCharsets.UTF_8`, because any other one out there is nonsense as a standard.
`static String`	`String(boolean value)`
`static String`	`String(byte value)`
`static String`	`String(byte[] chars)`
`static String`	`String(byte[] chars, Charset charset)`
`static String`	`String(byte[] chars, int offset, int length)`
`static String`	`String(byte[] chars, int offset, int length, Charset charset)`
`static String`	`String(ByteBuffer chars)`
`static String`	`String(ByteBuffer chars, Charset charset)`
`static String`	`String(ByteBuffer chars, int offset, int length)`
`static String`	`String(ByteBuffer chars, int offset, int length, Charset charset)`
`static String`	`String(char value)`
`static String`	`String(char[] chars)`
`static String`	`String(char[] chars, int offset, int length)`
`static String`	`String(double value)`
`static String`	`String(float value)`
`static String`	`String(int value)`
`static String`	`String(long value)`
`static String`	`String(short value)`
`static StringBuffer`	`StringBuffer(VarString vs)`
`static StringBuffer`	`StringBuffer(VarString vs, int offset, int length)`
`static StringBuilder`	`StringBuilder(VarString vs)`
`static StringBuilder`	`StringBuilder(VarString vs, int offset, int length)`
`static char[]`	`substring(char[] string, int offset, int bound)`
`static String`	`systemString(Object instance)` Utility method that replicates the JVM's intrinsic system string as defined in `Object.toString()`.
`static int`	`to_int(char digit)`
`static char[][]`	`toArrays(XGettingSequence<String> strings)`
`static char[]`	`toCharArray(CharSequence c)`
`static char[]`	`toCharArray(StringBuffer asb)`
`static char[]`	`toCharArray(StringBuilder asb)`
`static char`	`toHexadecimal(int b)`
`static String`	`toSingleLine(String multiLineString, String lineBreakReplacement)`
`static String`	`trim(String s)` Calls `String.trim()` on a non-null argument, returns `null` otherwise.
`static String`	`trimEmptyToNull(String s)`
`static String`	`trimToString(char[] input, int lowerOffset, int length)` Creates a `String` instance with trimmed content directly from a character sequence without unnecessary intermediate instances.
`static byte`	`uncheckedParse_byteDecimal(char[] input, int offset, int length)`
`static int`	`uncheckedParse_intLiteral(char[] input, int offset, int length)`
`static long`	`uncheckedParse_longLiteral(char[] input, int offset, int length)`
`static short`	`uncheckedParse_shortDecimal(char[] input, int offset, int length)`
`static String`	`upperCaseFirstChar(String s)` Ensures that the first character of the passed `String` is in upper case.
`static Charset`	`utf8()` It's UTF-8!
`static void`	`validateIndex(char[] chars, int index)`
`static void`	`validateRange(char[] chars, int offset, int length)`
`static String`	`valueString(Object value)` Returns `value.toString()` if the passed value is not null, otherwise null.

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

Method Detail

maxCharCount_byte

public static final int maxCharCount_byte()

maxCharCount_boolean

public static final int maxCharCount_boolean()

maxCharCount_short

public static final int maxCharCount_short()

maxCharCount_char

public static final int maxCharCount_char()

maxCharCount_int

public static final int maxCharCount_int()

maxCharCount_float

public static final int maxCharCount_float()

maxCharCount_long

public static final int maxCharCount_long()

maxCharCount_double

public static final int maxCharCount_double()

isWhitespace

public static final boolean isWhitespace(char c)

isNonWhitespace

public static final boolean isNonWhitespace(char c)

shortStringLength
```
public static final int shortStringLength()
```
Arbitrary threshold of 1000 to discrimate "short" strings from "long" strings.
The rationale behind that is that "short" strings usually allow for simpler and faster algorithms, which become inefficient on larger strings. For example a two-pass processing of a splitting algorithm.

Returns:

1000

utf8
```
public static final Charset utf8()
```
It's UTF-8!

Returns:

StandardCharsets.UTF_8

standardCharset
```
public static final Charset standardCharset()
```
Returns StandardCharsets.UTF_8, because any other one out there is nonsense as a standard.

Returns:

java.nio.charset.Charset.forName("UTF-8").

defaultJvmCharset
```
public static final Charset defaultJvmCharset()
```
Alias for Charset.defaultCharset(), which returns sometimes the one thing and sometimes another. It is strongly advised to use a reliable Charset querying method, like UTF-8, which also is the only reasonable choice for the standard charset.

Returns:

Charset.defaultCharset()

validateIndex

public static final void validateIndex(char[] chars,
                                       int index)

validateRange

public static final void validateRange(char[] chars,
                                       int offset,
                                       int length)

isEqual

public static final boolean isEqual(String s1,
                                    String s2)

equals

public static final boolean equals(String string,
                                   char[] chars,
                                   int offset)

equals

public static final boolean equals(char[] chars1,
                                   int offset1,
                                   char[] chars2,
                                   int offset2,
                                   int length)

isEqualIgnoreCase

public static final boolean isEqualIgnoreCase(String s1,
                                              String s2)

toHexadecimal

public static final char toHexadecimal(int b)
                                throws IllegalArgumentException

Throws:: IllegalArgumentException

indexOf

public static final int indexOf(char[] data,
                                char c)

indexOf

public static final int indexOf(char[] data,
                                int offset,
                                int length,
                                char c)

indexOf

public static final int indexOf(char[] source,
                                int sourceOffset,
                                int sourceCount,
                                char[] target,
                                int targetOffset,
                                int targetCount,
                                int fromIndex)

readAllBytesFromInputStream

public static final VarByte readAllBytesFromInputStream(VarByte bytes,
                                                        InputStream inputStream)
                                                 throws IOException

Throws:: IOException

readAllBytesFromInputStream

public static final VarByte readAllBytesFromInputStream(InputStream inputStream)
                                                 throws IOException

Throws:: IOException

readStringFromInputStream

public static final String readStringFromInputStream(InputStream inputStream,
                                                     Charset charset)
                                              throws IOException

Throws:: IOException

indexOf

public static final int indexOf(char[] data,
                                int dataLength,
                                char[] subject)

indexOf

public static final int indexOf(char[] data,
                                int dataOffset,
                                int dataLength,
                                char[] chars)

indexOf

public static final int indexOf(char[] source,
                                int sourceCount,
                                char[] target,
                                int targetCount,
                                int fromIndex)

replaceFirst

public static final int replaceFirst(char[] chars,
                                     int offset,
                                     int length,
                                     char sample,
                                     char replacement)

count

public static final int count(char[] input,
                              int startIndex,
                              int boundIndex,
                              char c)

count

public static final int count(char[] data,
                              int dataOffset,
                              int dataCount,
                              char[] subject,
                              int subjectOffset,
                              int subjectCount)

hasContent

public static final boolean hasContent(CharSequence s)

hasNoContent

public static final boolean hasNoContent(CharSequence s)

hasContent

public static final boolean hasContent(String s)

hasNoContent

public static final boolean hasNoContent(String s)

asString
```
public static final String asString(char c)
```
This method does intentionally not use the pseudo-constructor naming pattern since it does not create new instances of String. Instead, it returns a constant instance of an intrinsic look-up table.

Parameters:

c - the character value to be represented as a String.

Returns:

a String containing the passed character value.

asString

public static final String asString(char... chars)

upperCaseFirstChar
```
public static final String upperCaseFirstChar(String s)
```
Ensures that the first character of the passed String is in upper case.
If the passed String is null, has a length of 0 or already has an upper case first character, it is returned. Otherwise, the first character of the passed String is transformed to upper case and concatenated with the rest of the passed String into a new String instance.

Parameters:

s - the String for which the first character shall be ensured to be upper case.

Returns:

a string equalling s with its first character being guaranteed to be upper case.

lowerCaseFirstChar

public static final String lowerCaseFirstChar(String s)

concat

public static final char[] concat(char[]... arrays)

appendArraySeperated

public static final VarString appendArraySeperated(VarString vs,
                                                   String separator,
                                                   Object... elements)

appendArraySeperated

public static final VarString appendArraySeperated(VarString vc,
                                                   char separator,
                                                   Object... elements)

toCharArray

public static final char[] toCharArray(CharSequence c)

toCharArray

public static final char[] toCharArray(StringBuilder asb)

toCharArray

public static final char[] toCharArray(StringBuffer asb)

intersects
```
public static final boolean intersects(char[] chars1,
                                       char[] chars2)
```
Returns true if the two given character arrays have at least one character in common.

Parameters:

chars1 - first char array

chars2 - second char array

Returns:

true if the two given character arrays intersect each other.

append

public static final char[] append(char c,
                                  char[] string)

append

public static final char[] append(char[] string,
                                  char c)

append

public static final char[] append(char[] a,
                                  char[] b)

longestCommonSubstringLength

public static final int longestCommonSubstringLength(String a,
                                                     String b)

commonSubstringLength

public static final int commonSubstringLength(char[] a,
                                              char[] b)

longestCommonSubstring

public static final String longestCommonSubstring(String a,
                                                  String b)

longestCommonSubstring

public static final char[] longestCommonSubstring(char[] a,
                                                  char[] b)

substring

public static final char[] substring(char[] string,
                                     int offset,
                                     int bound)

convertUnderscoresToCamelCase

public static final String convertUnderscoresToCamelCase(String parameterName)

convertUnderscoresToCamelCase

public static final VarString convertUnderscoresToCamelCase(VarString vs,
                                                            String s)

longestCommonPrefixLength

public static final int longestCommonPrefixLength(String a,
                                                  String b)

longestCommonSuffixLength

public static final int longestCommonSuffixLength(String a,
                                                  String b)

longestCommonSuffix

public static final String longestCommonSuffix(String a,
                                               String b)

longestCommonPrefix

public static final String longestCommonPrefix(String a,
                                               String b)

commonPrefixLength

public static final int commonPrefixLength(char[] a,
                                           char[] b)

commonSuffixLength

public static final int commonSuffixLength(char[] a,
                                           char[] b)

longestCommonSuffix

public static final char[] longestCommonSuffix(char[] a,
                                               char[] b)

longestCommonPrefix

public static final char[] longestCommonPrefix(char[] a,
                                               char[] b)

padLeft

public static final String padLeft(String s,
                                   int totalLength,
                                   char paddingChar)

padRight

public static final String padRight(String s,
                                    int totalLength,
                                    char paddingChar)

padLeft

public static final String padLeft(String s,
                                   int totalLength)

padRight

public static final String padRight(String s,
                                    int totalLength)

padLeft0

public static final String padLeft0(String s,
                                    int totalLength)

padRight0

public static final String padRight0(String s,
                                     int totalLength)

parseChar
```
public static final char parseChar(String s)
```
Parses the char escape sequence Strings "\n" etc. (wihtout the "") to the singel char value represented by those strings.

Parameters:

s - the char escape sequence

Returns:

the resulting char

escapeChar

public static final VarString escapeChar(VarString vc,
                                         char c)

escapeChar

public static final String escapeChar(char c)

createMedialCapitalsString

public static final String createMedialCapitalsString(String... elements)

ensureCharAtEnd

public static final String ensureCharAtEnd(String s,
                                           char c)

toSingleLine

public static final String toSingleLine(String multiLineString,
                                        String lineBreakReplacement)

padSpace

public static final String padSpace(String s,
                                    int chars)

concat

public static final String concat(char separator,
                                  Object... parts)

notEmpty

public static final <C extends CharSequence> C notEmpty(C charSequence)

isEmpty

public static final boolean isEmpty(CharSequence cs)

iterate

public static final void iterate(CharSequence chars,
                                 _charProcedure iterator)

iterate

public static final void iterate(String chars,
                                 _charProcedure iterator)

iterate

public static final void iterate(char[] chars,
                                 _charProcedure iterator)

iterate

public static final void iterate(char[] chars,
                                 int offset,
                                 int length,
                                 _charProcedure iterator)

put

public static final int put(byte value,
                            char[] target,
                            int offset)

putHexDec

public static final int putHexDec(byte value,
                                  char[] target,
                                  int offset)

put

public static final int put(boolean value,
                            char[] target,
                            int offset)

put

public static final int put(short value,
                            char[] target,
                            int offset)

put

public static final int put(int value,
                            char[] target,
                            int offset)

put

public static final int put(float value,
                            char[] target,
                            int offset)

put

public static final int put(long value,
                            char[] target,
                            int offset)

put

public static final int put(double value,
                            char[] target,
                            int offset)

put

public static final int put(String s,
                            char[] target,
                            int offset)

put

public static final int put(char[] value,
                            char[] target,
                            int offset)

putNull

public static final int putNull(char[] target,
                                int offset)

putTrue

public static final int putTrue(char[] target,
                                int offset)

putFalse

public static final int putFalse(char[] target,
                                 int offset)

String

public static final String String(byte value)

String

public static final String String(boolean value)

String

public static final String String(short value)

String

public static final String String(char value)

String

public static final String String(int value)

String

public static final String String(float value)

String

public static final String String(long value)

String

public static final String String(double value)

String

public static final String String(char[] chars)

String

public static final String String(char[] chars,
                                  int offset,
                                  int length)

String

public static final String String(byte[] chars)

String

public static final String String(byte[] chars,
                                  Charset charset)

String

public static final String String(byte[] chars,
                                  int offset,
                                  int length)

String

public static final String String(byte[] chars,
                                  int offset,
                                  int length,
                                  Charset charset)

String

public static final String String(ByteBuffer chars)

String

public static final String String(ByteBuffer chars,
                                  Charset charset)

String

public static final String String(ByteBuffer chars,
                                  int offset,
                                  int length)

String

public static final String String(ByteBuffer chars,
                                  int offset,
                                  int length,
                                  Charset charset)

StringBuilder

public static final StringBuilder StringBuilder(VarString vs)

StringBuilder

public static final StringBuilder StringBuilder(VarString vs,
                                                int offset,
                                                int length)

StringBuffer

public static final StringBuffer StringBuffer(VarString vs)

StringBuffer

public static final StringBuffer StringBuffer(VarString vs,
                                              int offset,
                                              int length)

readChars

public static final char[] readChars(String s)

hashCode
```
public static final int hashCode(char[] chars,
                                 int offset,
                                 int length)
```
This method rebuilds the String hashing algorithm.
Returns a hash code for the passed character range. The hash code is computed as
```
 s[0]*31^(n - 1) + s[1]*31^(n-2) + ... + s[n - 1]
 
```
using int arithmetic, where s[i] is the ith character counted from the given offset, n is the length and ^ indicates exponentiation. The hash value of an empty range is zero.
Parameters:

chars - the character array

offset - the start offset

length - the length

Returns:

a hash code value for this object.

See Also:

String.hashCode()

splitAndTrimToStrings
```
public static final <C extends Consumer<String>> C splitAndTrimToStrings(String input,
                                                                         char separator,
                                                                         C collector)
```
High-performance implementation of the very common case to split a string by a single character and trim all elements.

Type Parameters:

C - the collector type

Parameters:

input - the String to split

separator - the separator char to split on

collector - the result collector

Returns:

the collector

See Also:

trimToString(char[], int, int)

splitAndTrimToStrings
```
public static final <C extends Consumer<String>> C splitAndTrimToStrings(char[] input,
                                                                         char separator,
                                                                         C collector)
```
High-performance implementation of the very common case to split a character sequence by a single character and trim all elements.

Type Parameters:

C - the collector type

Parameters:

input - the char array to split

separator - the separator char to split on

collector - the result collector

Returns:

the collector

See Also:

trimToString(char[], int, int)

splitSimple

public static String[] splitSimple(String s,
                                   String separator)

splitSimple

public static <C extends Consumer<? super String>> C splitSimple(String s,
                                                                 String separator,
                                                                 C collector)

trimToString
```
public static final String trimToString(char[] input,
                                        int lowerOffset,
                                        int length)
```
Creates a String instance with trimmed content directly from a character sequence without unnecessary intermediate instances.

Parameters:

input - the source char array to trim

lowerOffset - the start offset

length - the length

Returns:

the trimmed String

trim
```
public static String trim(String s)
```
Calls String.trim() on a non-null argument, returns null otherwise. (this is nothing but a static String.trim())

Parameters:

s - the String instance to be trimmed, potentially null.

Returns:

a potentially null trimmed String instance.

parseTo_intArray

public static final int[] parseTo_intArray(String... intStrings)

parseToIntegerArray

public static final Integer[] parseToIntegerArray(String... intStrings)

assembleNewLinedTabbed

public static final VarString assembleNewLinedTabbed(VarString vs,
                                                     CharSequence... elements)

assembleSeparated

public static final VarString assembleSeparated(VarString vs,
                                                char separator,
                                                CharSequence... elements)

parse_byteDecimal

public static final byte parse_byteDecimal(char[] input)

parse_shortDecimal

public static final short parse_shortDecimal(char[] input)

parse_intLiteral

public static final int parse_intLiteral(char[] input)

parse_longDecimal

public static final long parse_longDecimal(char[] input)

parse_byteDecimal

public static final byte parse_byteDecimal(char[] input,
                                           int offset,
                                           int length)

parse_shortDecimal

public static final short parse_shortDecimal(char[] input,
                                             int offset,
                                             int length)

parse_intLiteral

public static final int parse_intLiteral(char[] input,
                                         int offset,
                                         int length)

parse_longDecimal

public static final long parse_longDecimal(char[] input,
                                           int offset,
                                           int length)

parse_float

public static final float parse_float(char[] input,
                                      int offset,
                                      int length)

parse_double

public static final double parse_double(char[] input,
                                        int offset,
                                        int length)

uncheckedParse_byteDecimal

public static final byte uncheckedParse_byteDecimal(char[] input,
                                                    int offset,
                                                    int length)

uncheckedParse_shortDecimal

public static final short uncheckedParse_shortDecimal(char[] input,
                                                      int offset,
                                                      int length)

uncheckedParse_intLiteral

public static final int uncheckedParse_intLiteral(char[] input,
                                                  int offset,
                                                  int length)

uncheckedParse_longLiteral

public static final long uncheckedParse_longLiteral(char[] input,
                                                    int offset,
                                                    int length)

internalParse_longLiteral
```
public static final long internalParse_longLiteral(char[] input,
                                                   int offset,
                                                   int length)
```
Specialcase higher performance implementation of decimal integer literal parsing. Because as usual, the JDK implementation strategies are not acceptable when dealing with non-trivial amounts of data. Properly executed performance tests (large loop sizes, averages, nanosecond precision, etc.) showed that this algorithms is more than twice as fast as the one used in JDK (average of ~33µs vs ~75µs for long literals on same machine with measuring overhead of ~1.5µs)

Parameters:

input - the source char array

offset - the start offset

length - the length

Returns:

the parsed long value

to_int

public static final int to_int(char digit)

toArrays

public static final char[][] toArrays(XGettingSequence<String> strings)

contains

public static final boolean contains(String[] strings,
                                     String subject)

contains

public static final boolean contains(String s,
                                     char c)

contains

public static final boolean contains(char[] subject,
                                     int subjectOffset,
                                     int subjectLength,
                                     char[] sample,
                                     int sampleOffset,
                                     int sampleLength)

contains

public static final boolean contains(char[] data,
                                     char c)

contains

public static final boolean contains(char[] data,
                                     int dataOffset,
                                     int dataLength,
                                     char c)

systemString
```
public static String systemString(Object instance)
```
Utility method that replicates the JVM's intrinsic system string as defined in Object.toString(). (It's funny how much functionality is missing in the JDK API).

Parameters:

instance - the instance whose system string shall be generated.

Returns:

the system string for the passed instance.

addSystemString

public static VarString addSystemString(Object instance,
                                        VarString vs)

nonNullString

public static String nonNullString(Object object)

valueString
```
public static String valueString(Object value)
```
Returns value.toString() if the passed value is not null, otherwise null.
Note that this is a different behavior than String.valueOf(Object) has, as the latter returns the string "null" for a passed null reference. The latter is merely an output helper method, albeit clumsily named and placed as if it were a general utility method. THIS method here is the far more useful general utility method.
The behavior of this method is needed for example for converting values in a generic data structure (e.g. a Object[] array) to string values but have the actual values, including null (information about a missing value), maintained.

Parameters:

value - the value to be projected to its string representation if not null.

Returns:

a string representation of an actual passed value or a transient null.

See Also:

Object.toString(), String.valueOf(Object)

trimEmptyToNull

public static String trimEmptyToNull(String s)

assembleCautiously
```
public static final VarString assembleCautiously(VarString vs,
                                                 Object object)
```
Assembles the passed instance "cautiously" in the sense that only types recognizable via XTypes.isValueType(Object) get assembled using their Object.toString() method, while all others are assembled using systemString(Object) (which behaves identical to the actual implementation of Object.toString()).

Parameters:

vs - the VarString instance to hold the assembled string.

object - the instance to be assembled "cautiously" as described above.

Returns:

the passed vs instance (method-chaining viable).

See Also:

VarString.add(Object, java.util.function.BiConsumer), XTypes.isValueType(Object), Object.toString(), systemString(Object)

applies

public static final boolean applies(CharSequence chars,
                                    _charPredicate predicate)

applies

public static final boolean applies(CharSequence chars,
                                    int startIndex,
                                    _charPredicate predicate)

isDigit

public static boolean isDigit(char c)

randomReadable_char

public static char randomReadable_char()

countCharacter

public static int countCharacter(String data,
                                 char c)

countCodePoint

public static int countCodePoint(String data,
                                 int codePoint)

mathRangeIncInc

public static String mathRangeIncInc(long minimum,
                                     long maximum)

mathRangeIncExc

public static String mathRangeIncExc(long minimum,
                                     long upperBound)

mathRangeExcInc

public static String mathRangeExcInc(long lowerBound,
                                     long maximum)

mathRangeExcExc

public static String mathRangeExcExc(long lowerBound,
                                     long upperBound)

mathRangeIncInc

public static String mathRangeIncInc(double minimum,
                                     double maximum)

mathRangeIncExc

public static String mathRangeIncExc(double minimum,
                                     double upperBound)

mathRangeExcInc

public static String mathRangeExcInc(double lowerBound,
                                     double maximum)

mathRangeExcExc

public static String mathRangeExcExc(double lowerBound,
                                     double upperBound)

mathRangeIncInc

public static String mathRangeIncInc(String minimum,
                                     String maximum)

mathRangeIncExc

public static String mathRangeIncExc(String minimum,
                                     String upperBound)

mathRangeExcInc

public static String mathRangeExcInc(String lowerBound,
                                     String maximum)

mathRangeExcExc

public static String mathRangeExcExc(String lowerBound,
                                     String upperBound)

Class XChars

Method Summary

Methods inherited from class java.lang.Object

Method Detail

maxCharCount_byte

maxCharCount_boolean

maxCharCount_short

maxCharCount_char

maxCharCount_int

maxCharCount_float

maxCharCount_long

maxCharCount_double

isWhitespace

isNonWhitespace

shortStringLength

utf8

standardCharset

defaultJvmCharset

validateIndex

validateRange

isEqual

equals

equals

isEqualIgnoreCase

toHexadecimal

indexOf

indexOf

indexOf

readAllBytesFromInputStream

readAllBytesFromInputStream

readStringFromInputStream

indexOf

indexOf

indexOf

replaceFirst

count

count

hasContent

hasNoContent

hasContent

hasNoContent

asString

asString

upperCaseFirstChar

lowerCaseFirstChar

concat

appendArraySeperated

appendArraySeperated

toCharArray

toCharArray

toCharArray

intersects

append

append

append

longestCommonSubstringLength

commonSubstringLength

longestCommonSubstring

longestCommonSubstring

substring

convertUnderscoresToCamelCase

convertUnderscoresToCamelCase

longestCommonPrefixLength

longestCommonSuffixLength

longestCommonSuffix

longestCommonPrefix

commonPrefixLength

commonSuffixLength

longestCommonSuffix

longestCommonPrefix

padLeft

padRight

padLeft

padRight

padLeft0

padRight0

parseChar

escapeChar

escapeChar

createMedialCapitalsString