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

Modifier and Type	Method	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, int startIndex, _charPredicate predicate)`
`static boolean`	`applies(CharSequence chars, _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 c)`	This method does intentionally not use the pseudo-constructor naming pattern since it does not create new instances of `String`.
`static String`	`asString(char... chars)`
`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 as the JDK guys forgot as usual to make their stuff professionally modular.
`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, int offset, int length, _charProcedure iterator)`
`static void`	`iterate(char[] chars, _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, int offset, int length)`
`static String`	`String(byte[] chars, int offset, int length, Charset charset)`
`static String`	`String(byte[] chars, 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 String`	`String(ByteBuffer chars)`
`static String`	`String(ByteBuffer chars, int offset, int length)`
`static String`	`String(ByteBuffer chars, int offset, int length, Charset charset)`
`static String`	`String(ByteBuffer chars, Charset charset)`
`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 Details
- 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 -
  
  chars2 -
  
  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 -
- 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 as the JDK guys forgot as usual to make their stuff professionally modular.
  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.
  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.
  
  Parameters:
  
  input -
  
  separator -
  
  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.
  
  Parameters:
  
  input -
  
  separator -
  
  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 -
  
  lowerOffset -
  
  length -
- 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 -
  
  offset -
  
  length -
- 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 Details