IOUtils

java.lang.Object
- com.alibaba.fastjson2.util.IOUtils

```
public class IOUtils
extends java.lang.Object
```
IOUtils is a utility class that provides various I/O operations and helper methods for working with byte arrays, character arrays, and other data structures used in FASTJSON2 for serialization and deserialization.
This class contains optimized methods for:
- Writing and reading primitive values to/from byte and character arrays
- Handling UTF-8 and UTF-16 encoding/decoding
- Working with date/time values
- Performing low-level memory operations
- Managing resource cleanup
All methods in this class are static and thread-safe.
Since:

2.0.0

Field Summary

Fields
Modifier and Type	Field and Description
`(package private) static int`	`ALSE`
`(package private) static long`	`ALSE_64`
`static int[]`	`DIGITS_K_32`
`static long[]`	`DIGITS_K_64`
`static long`	`DOT_X0`
`(package private) static short`	`DOT_ZERO_16`
`(package private) static int`	`DOT_ZERO_32`
`private static byte[]`	`MIN_LONG_BYTES`
`private static char[]`	`MIN_LONG_CHARS`
`(package private) static int`	`NULL_32`
`(package private) static long`	`NULL_64`
`static short[]`	`PACKED_DIGITS`
`static int[]`	`PACKED_DIGITS_UTF16`
`(package private) static long[]`	`POWER_TEN`
`(package private) static int[]`	`sizeTable`
`(package private) static int`	`TRUE`
`(package private) static long`	`TRUE_64`
`(package private) static short`	`ZERO_DOT_16`
`(package private) static int`	`ZERO_DOT_32`
`private static short`	`ZERO_DOT_LATIN1`
`(package private) static short`	`ZERO_ZERO_16`
`(package private) static int`	`ZERO_ZERO_32`

Constructor Summary

Constructors
Constructor and Description

IOUtils()

Constructors
Constructor and Description
`IOUtils()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static void`	`close(java.io.Closeable x)` Safely closes a Closeable resource, ignoring any exceptions that may occur.
`static int`	`convEndian(boolean big, int n)` Converts an integer value between big-endian and little-endian byte orders.
`static long`	`convEndian(boolean big, long n)` Converts a long value between big-endian and little-endian byte orders.
`(package private) static short`	`convEndian(boolean big, short n)`
`static int`	`decodeUTF8(byte[] src, int off, int len, byte[] dst)` Decodes UTF-8 encoded byte array to a UTF-16 byte array.
`static int`	`decodeUTF8(byte[] src, int off, int len, char[] dst)` Decodes UTF-8 encoded byte array to a character array.
`static int`	`digit(int d)` Validates if the specified integer value represents a single digit (0-9).
`static int`	`digit1(byte[] buf, int off)` Extracts a single digit from a byte array at the specified offset.
`static int`	`digit1(char[] buf, int off)` Extracts a single digit from a character array at the specified offset.
`static int`	`digit2(byte[] buf, int off)` Extracts a 2-digit number from a byte array at the specified offset.
`static int`	`digit2(char[] buf, int off)` Extracts a 2-digit number from a character array at the specified offset.
`static int`	`digit3(byte[] buf, int off)` Extracts a 3-digit number from a byte array at the specified offset.
`static int`	`digit3(char[] buf, int off)` Extracts a 3-digit number from a character array at the specified offset.
`private static int`	`digit3(int x)` Extracts a 3-digit number from an integer value.
`static int`	`digit4(byte[] buf, int off)` Extracts a 4-digit number from a byte array at the specified offset.
`static int`	`digit4(char[] buf, int off)` Extracts a 4-digit number from a character array at the specified offset.
`private static int`	`digit4(int x)` Extracts a 4-digit number from an integer value.
`private static short`	`digitPair(int value)`
`static int`	`encodeUTF8(byte[] src, int offset, int len, byte[] dst, int dp)` Encodes a UTF-16 byte array to UTF-8 byte array.
`static int`	`encodeUTF8(char[] src, int offset, int len, byte[] dst, int dp)` Encodes a UTF-16 character array to UTF-8 byte array.
`static byte`	`getByte(byte[] buf, int pos)` Gets a byte value from a byte array at the specified position.
`static char`	`getChar(byte[] buf, int pos)` Gets a character value from a byte array at the specified position.
`static char`	`getChar(char[] buf, int pos)` Gets a character value from a character array at the specified position.
`static void`	`getChars(int i, int index, byte[] buf)` Converts an integer to its character representation and writes it to a byte array.
`static void`	`getChars(int i, int index, char[] buf)` Converts an integer to its character representation and writes it to a character array.
`static void`	`getChars(long i, int index, byte[] buf)` Converts a long integer to its character representation and writes it to a byte array.
`static void`	`getChars(long i, int index, char[] buf)` Converts a long integer to its character representation and writes it to a character array.
`static int`	`getIntBE(byte[] buf, int offset)` Gets an int value from a byte array at the specified offset in big-endian byte order.
`static int`	`getIntLE(byte[] buf, int offset)` Gets an int value from a byte array at the specified offset in little-endian byte order.
`static int`	`getIntLE(char[] buf, int offset)` Gets an int value from a character array at the specified offset in little-endian byte order.
`static int`	`getIntUnaligned(byte[] buf, int offset)` Gets an int value from a byte array at the specified offset without alignment considerations.
`static int`	`getIntUnaligned(char[] buf, int offset)` Gets an int value from a character array at the specified offset without alignment considerations.
`static long`	`getLongBE(byte[] buf, int offset)` Gets a long value from a byte array at the specified offset in big-endian byte order.
`static long`	`getLongLE(byte[] buf, int offset)` Gets a long value from a byte array at the specified offset in little-endian byte order.
`static long`	`getLongLE(char[] buf, int offset)` Gets a long value from a character array at the specified offset in little-endian byte order.
`static long`	`getLongUnaligned(byte[] buf, int offset)` Gets a long value from a byte array at the specified offset without alignment considerations.
`static long`	`getLongUnaligned(char[] buf, int offset)` Gets a long value from a character array at the specified offset without alignment considerations.
`static short`	`getShortBE(byte[] buf, int offset)` Gets a short value from a byte array at the specified offset in big-endian byte order.
`static short`	`getShortLE(byte[] buf, int offset)` Gets a short value from a byte array at the specified offset in little-endian byte order.
`static short`	`getShortUnaligned(byte[] buf, int offset)` Gets a short value from a byte array at the specified offset without alignment considerations.
`static short`	`hex2(int i)` Converts a 2-digit hexadecimal value to its character representation.
`static short`	`hex2U(int i)` Converts a 2-digit hexadecimal value to its uppercase character representation.
`static int`	`hex4U(int i)` Converts a 4-digit hexadecimal value to its uppercase character representation.
`static int`	`hexDigit4(byte[] buf, int offset)` Extracts a 4-digit hexadecimal number from a byte array at the specified offset.
`static int`	`hexDigit4(byte[] buf, int offset, int end)`
`static int`	`hexDigit4(char[] buf, int offset)` Extracts a 4-digit hexadecimal number from a character array at the specified offset.
`static int`	`hexDigit4(char[] buf, int offset, int end)`
`static int`	`indexOfChar(byte[] buf, int ch, int fromIndex, int max)` Finds the index of a character in a byte array.
`static int`	`indexOfChar(char[] buf, int ch, int fromIndex, int max)` Finds the index of a character in a character array.
`static int`	`indexOfDoubleQuote(byte[] buf, int fromIndex, int max)` Finds the index of a double quote character in a byte array.
`static int`	`indexOfDoubleQuoteV(byte[] buf, int fromIndex, int max)` Finds the index of a double quote character in a byte array using vectorized operations.
`static int`	`indexOfLineSeparator(byte[] buf, int fromIndex, int max)` Finds the index of a line separator character in a byte array.
`static int`	`indexOfLineSeparatorV(byte[] buf, int fromIndex, int max)` Finds the index of a line separator character in a byte array using vectorized operations.
`static int`	`indexOfQuote(byte[] buf, int quote, int fromIndex, int max)` Finds the index of a quote character in a byte array.
`static int`	`indexOfQuoteV(byte[] buf, int quote, int fromIndex, int max)` Finds the index of a quote character in a byte array using vectorized operations.
`static int`	`indexOfSlash(byte[] buf, int fromIndex, int max)` Finds the index of a slash character in a byte array.
`static int`	`indexOfSlashV(byte[] buf, int fromIndex, int max)` Finds the index of a slash character in a byte array using vectorized operations.
`static boolean`	`isALSE(byte[] buf, int pos)` Checks if the specified position in a byte array contains the string "alse".
`static boolean`	`isALSE(char[] buf, int pos)` Checks if the specified position in a character array contains the string "alse".
`static boolean`	`isASCII(byte[] buf)` Checks if a byte array contains only ASCII characters.
`static boolean`	`isASCII(byte[] buf, int off, int len)` Checks if a byte array segment contains only ASCII characters.
`static boolean`	`isASCII(java.lang.String str)` Checks if a string contains only ASCII characters.
`static boolean`	`isDigit(int ch)` Checks if the specified character is a digit (0-9).
`static boolean`	`isDigit2(char[] buf, int off)` Checks if the 2 characters at the specified offset in a character array represent valid digits.
`private static boolean`	`isDigitLatin1(int c)`
`static boolean`	`isLatin1(char[] buf, int off, int len)` Checks if a character array segment contains only Latin-1 characters.
`static boolean`	`isNonSlashASCII(byte[] buf, int off, int len)` Checks if a byte array segment contains only ASCII characters and no backslash characters.
`static boolean`	`isNULL(byte[] buf, int pos)` Checks if the specified position in a byte array contains the string "null".
`static boolean`	`isNULL(char[] buf, int pos)` Checks if the specified position in a character array contains the string "null".
`static boolean`	`isNumber(byte[] buf, int off, int len)` Checks if the byte array segment represents a valid number.
`static boolean`	`isNumber(char[] buf, int off, int len)` Checks if the character array segment represents a valid number.
`static boolean`	`isNumber(java.lang.String str)` Checks if the given string represents a valid number.
`static boolean`	`isUTF8BOM(byte[] buf, int off)` Checks if the specified position in a byte array contains a UTF-8 Byte Order Mark (BOM).
`static long`	`lines(java.io.File file)` Counts the number of lines in a file.
`static long`	`lines(java.io.InputStream in)` Counts the number of lines in an InputStream.
`private static long`	`mergeInt64(int v1, int v2)`
`static boolean`	`notALSE(byte[] buf, int pos)` Checks if the specified position in a byte array does not contain the string "alse".
`static boolean`	`notALSE(char[] buf, int pos)` Checks if the specified position in a character array does not contain the string "alse".
`private static boolean`	`notContains(long value, long vector)`
`static boolean`	`notNULL(byte[] buf, int pos)` Checks if the specified position in a byte array does not contain the string "null".
`static boolean`	`notNULL(char[] buf, int pos)` Checks if the specified position in a character array does not contain the string "null".
`static boolean`	`notTRUE(byte[] buf, int pos)` Checks if the specified position in a byte array does not contain the string "true".
`static boolean`	`notTRUE(char[] buf, int pos)` Checks if the specified position in a character array does not contain the string "true".
`(package private) static JSONException`	`outOfBoundsCheckFromToIndex(int offset, int end)`
`static int`	`parseInt(byte[] buf, int off, int len)` Parses an integer value from a byte array segment.
`static int`	`putBoolean(byte[] buf, int off, boolean v)` Writes a boolean value to a byte array as a string representation.
`static int`	`putBoolean(char[] buf, int off, boolean v)` Writes a boolean value to a character array as a string representation.
`private static void`	`putByte(byte[] buf, int pos, byte v)`
`private static void`	`putChar(char[] buf, int pos, char v)`
`static void`	`putIntBE(byte[] buf, int pos, int v)` Writes an int value to a byte array in big-endian byte order.
`static void`	`putIntLE(byte[] buf, int pos, int v)` Writes an int value to a byte array in little-endian byte order.
`static void`	`putIntLE(char[] buf, int pos, int v)` Writes an int value to a character array in little-endian byte order.
`static void`	`putIntUnaligned(byte[] buf, int pos, int v)` Writes an int value to a byte array without alignment considerations.
`static void`	`putIntUnaligned(char[] buf, int pos, int v)` Writes an int value to a character array without alignment considerations.
`static void`	`putLongBE(byte[] buf, int pos, long v)` Writes a long value to a byte array in big-endian byte order.
`static void`	`putLongLE(byte[] buf, int pos, long v)` Writes a long value to a byte array in little-endian byte order.
`static void`	`putLongLE(char[] buf, int pos, long v)` Writes a long value to a character array in little-endian byte order.
`static void`	`putLongUnaligned(byte[] buf, int pos, long v)` Writes a long value to a byte array without alignment considerations.
`static void`	`putLongUnaligned(char[] buf, int pos, long v)` Writes a long value to a character array without alignment considerations.
`static void`	`putNULL(byte[] buf, int pos)` Writes the string "null" to a byte array at the specified position.
`static void`	`putNULL(char[] buf, int pos)` Writes the string "null" to a character array at the specified position.
`static void`	`putShortBE(byte[] buf, int pos, short v)` Writes a short value to a byte array in big-endian byte order.
`static void`	`putShortLE(byte[] buf, int pos, short v)` Writes a short value to a byte array in little-endian byte order.
`static void`	`putShortUnaligned(byte[] buf, int pos, short v)` Writes a short value to a byte array without alignment considerations.
`static boolean`	`regionMatches(byte[] bytes, int off, java.lang.String prefix)` Checks if a byte array region matches a prefix string.
`private static int`	`reverseBytesExpand(int i)`
`static int`	`stringSize(int x)` Calculates the string size (number of digits) needed to represent an integer value.
`static int`	`stringSize(long x)` Calculates the string size (number of digits) needed to represent a long value.
`static int`	`utf16Hex2(int i)` Converts a 2-digit hexadecimal value to its UTF-16 character representation.
`static long`	`utf16Hex4U(long i)` Converts a 4-digit hexadecimal value to its uppercase UTF-16 character representation.
`private static long`	`utf16ReverseBytesExpand(long i)`
`private static void`	`utf8_char2(byte[] src, int offset, int sl, char c, byte[] dst, int dp)`
`private static void`	`utf8_char2(char[] src, int offset, int sl, char c, byte[] dst, int dp)`
`static int`	`writeDecimal(byte[] buf, int off, long unscaledVal, int scale)` Writes a decimal number to a byte array buffer
`static int`	`writeDecimal(char[] buf, int off, long unscaledVal, int scale)` Writes a decimal number to a character array buffer
`static void`	`writeDigitPair(byte[] buf, int charPos, int value)` Writes a pair of digits to a byte array at the specified position.
`static void`	`writeDigitPair(char[] buf, int charPos, int value)` Writes a pair of digits to a character array at the specified position.
`static int`	`writeInt16(byte[] buf, int pos, short value)` Writes a 16-bit short value as an integer to a byte array.
`static int`	`writeInt16(char[] buf, int pos, short value)` Writes a 16-bit short value as an integer to a character array.
`private static int`	`writeInt3(byte[] buf, int off, int val)`
`private static int`	`writeInt3(char[] buf, int off, int val)`
`static int`	`writeInt32(byte[] buf, int off, long val)` Writes a 32-bit integer value to a byte array.
`static int`	`writeInt32(char[] buf, int off, long val)` Writes a 32-bit integer value to a character array.
`private static int`	`writeInt4(byte[] buf, int off, int v)`
`private static int`	`writeInt4(char[] buf, int off, int v)`
`static int`	`writeInt64(byte[] buf, int off, long val)` Writes a 64-bit long integer value to a byte array.
`static int`	`writeInt64(char[] buf, int off, long val)` Writes a 64-bit long integer value to a character array.
`static int`	`writeInt8(byte[] buf, int pos, byte value)` Writes an 8-bit byte value as an integer to a byte array.
`private static int`	`writeInt8(byte[] buf, int off, int v1, int v2)`
`static int`	`writeInt8(char[] buf, int pos, byte value)` Writes an 8-bit byte value as an integer to a character array.
`private static int`	`writeInt8(char[] buf, int off, int v1, int v2)`
`static int`	`writeLocalDate(byte[] buf, int off, int year, int month, int dayOfMonth)` Writes a LocalDate value to a byte array in ISO8601 format (yyyy-MM-dd).
`static int`	`writeLocalDate(char[] buf, int off, int year, int month, int dayOfMonth)` Writes a LocalDate value to a character array in ISO8601 format (yyyy-MM-dd).
`static void`	`writeLocalTime(byte[] buf, int off, int hour, int minute, int second)` Writes a LocalTime value to a byte array in ISO8601 format (HH:mm:ss).
`static int`	`writeLocalTime(byte[] buf, int off, java.time.LocalTime time)` Writes a LocalTime value to a byte array in ISO8601 format (HH:mm:ss[.nnnnnnnnn]).
`static void`	`writeLocalTime(char[] buf, int off, int hour, int minute, int second)` Writes a LocalTime value to a character array in ISO8601 format (HH:mm:ss).
`static int`	`writeLocalTime(char[] buf, int off, java.time.LocalTime time)` Writes a LocalTime value to a character array in ISO8601 format (HH:mm:ss[.nnnnnnnnn]).
`static int`	`writeNano(byte[] buf, int off, int nano)` Writes nanosecond values to a byte array.
`static int`	`writeNano(char[] buf, int off, int nano)` Writes nanosecond values to a character array.

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

- Field Detail
  - DOT_ZERO_16
```
static final short DOT_ZERO_16
```
  - DOT_ZERO_32
```
static final int DOT_ZERO_32
```
  - ZERO_DOT_16
```
static final short ZERO_DOT_16
```
  - ZERO_DOT_32
```
static final int ZERO_DOT_32
```
  - ZERO_ZERO_16
```
static final short ZERO_ZERO_16
```
    See Also:
    
    Constant Field Values
  - ZERO_ZERO_32
```
static final int ZERO_ZERO_32
```
    See Also:
    
    Constant Field Values
  - NULL_32
```
static final int NULL_32
```
  - NULL_64
```
static final long NULL_64
```
  - TRUE
```
static final int TRUE
```
  - TRUE_64
```
static final long TRUE_64
```
  - ALSE
```
static final int ALSE
```
  - ALSE_64
```
static final long ALSE_64
```
  - DOT_X0
```
public static final long DOT_X0
```
  - sizeTable
```
static final int[] sizeTable
```
  - DIGITS_K_32
```
public static final int[] DIGITS_K_32
```
  - DIGITS_K_64
```
public static final long[] DIGITS_K_64
```
  - MIN_LONG_BYTES
```
private static final byte[] MIN_LONG_BYTES
```
  - MIN_LONG_CHARS
```
private static final char[] MIN_LONG_CHARS
```
  - PACKED_DIGITS
```
public static final short[] PACKED_DIGITS
```
  - PACKED_DIGITS_UTF16
```
public static final int[] PACKED_DIGITS_UTF16
```
  - POWER_TEN
```
static final long[] POWER_TEN
```
  - ZERO_DOT_LATIN1
```
private static final short ZERO_DOT_LATIN1
```
- Constructor Detail
  - IOUtils
```
public IOUtils()
```
- Method Detail
  - digitPair
```
private static short digitPair(int value)
```
  - writeDigitPair
```
public static void writeDigitPair(byte[] buf,
                                  int charPos,
                                  int value)
```
    Writes a pair of digits to a byte array at the specified position. This method is used for efficient digit pair writing during number formatting.
    
    Parameters:
    
    buf - the byte array buffer to write to
    
    charPos - the position in the buffer where to write the digit pair
    
    value - the value (0-99) to write as a digit pair
  - writeDigitPair
```
public static void writeDigitPair(char[] buf,
                                  int charPos,
                                  int value)
```
    Writes a pair of digits to a character array at the specified position. This method is used for efficient digit pair writing during number formatting.
    
    Parameters:
    
    buf - the character array buffer to write to
    
    charPos - the position in the buffer where to write the digit pair
    
    value - the value (0-99) to write as a digit pair
  - stringSize
```
public static int stringSize(int x)
```
    Calculates the string size (number of digits) needed to represent an integer value. This method is used to determine the buffer size needed for number formatting.
    
    Parameters:
    
    x - the integer value to calculate the string size for
    
    Returns:
    
    the number of digits needed to represent the integer value
  - stringSize
```
public static int stringSize(long x)
```
    Calculates the string size (number of digits) needed to represent a long value. This method is used to determine the buffer size needed for number formatting.
    
    Parameters:
    
    x - the long value to calculate the string size for
    
    Returns:
    
    the number of digits needed to represent the long value
  - getChars
```
public static void getChars(int i,
                            int index,
                            byte[] buf)
```
    Converts an integer to its character representation and writes it to a byte array. This method handles negative numbers and optimizes digit conversion by processing two digits at a time when possible.
    
    Parameters:
    
    i - the integer value to convert
    
    index - the starting index in the buffer where to write the characters
    
    buf - the byte array buffer to write the characters to
  - getChars
```
public static void getChars(int i,
                            int index,
                            char[] buf)
```
    Converts an integer to its character representation and writes it to a character array. This method handles negative numbers and optimizes digit conversion by processing two digits at a time when possible.
    
    Parameters:
    
    i - the integer value to convert
    
    index - the starting index in the buffer where to write the characters
    
    buf - the character array buffer to write the characters to
  - getChars
```
public static void getChars(long i,
                            int index,
                            byte[] buf)
```
    Converts a long integer to its character representation and writes it to a byte array. This method handles negative numbers and optimizes digit conversion by processing two digits at a time when possible, switching to int-based processing when the value fits in an integer.
    
    Parameters:
    
    i - the long integer value to convert
    
    index - the starting index in the buffer where to write the characters
    
    buf - the byte array buffer to write the characters to
  - getChars
```
public static void getChars(long i,
                            int index,
                            char[] buf)
```
    Converts a long integer to its character representation and writes it to a character array. This method handles negative numbers and optimizes digit conversion by processing two digits at a time when possible, switching to int-based processing when the value fits in an integer.
    
    Parameters:
    
    i - the long integer value to convert
    
    index - the starting index in the buffer where to write the characters
    
    buf - the character array buffer to write the characters to
  - writeDecimal
```
public static int writeDecimal(byte[] buf,
                               int off,
                               long unscaledVal,
                               int scale)
```
    Writes a decimal number to a byte array buffer
    
    Parameters:
    
    buf - byte array buffer
    
    off - buffer starting offset
    
    unscaledVal - unscaled value (precision part of BigDecimal)
    
    scale - number of digits after the decimal point, caller must ensure scale >= 0
    
    Returns:
    
    offset after writing Note: This method trusts that the caller has ensured scale >= 0
  - writeDecimal
```
public static int writeDecimal(char[] buf,
                               int off,
                               long unscaledVal,
                               int scale)
```
    Writes a decimal number to a character array buffer
    
    Parameters:
    
    buf - character array buffer
    
    off - buffer starting offset
    
    unscaledVal - unscaled value (precision part of BigDecimal)
    
    scale - number of digits after the decimal point, caller must ensure scale >= 0
    
    Returns:
    
    offset after writing Note: This method trusts that the caller has ensured scale >= 0
  - encodeUTF8
```
public static int encodeUTF8(byte[] src,
                             int offset,
                             int len,
                             byte[] dst,
                             int dp)
```
    Encodes a UTF-16 byte array to UTF-8 byte array. This method converts characters from a source byte array (containing UTF-16 encoded data) to a destination byte array in UTF-8 encoding format.
    
    Parameters:
    
    src - the source byte array containing UTF-16 encoded data
    
    offset - the starting offset in the source array
    
    len - the number of bytes to encode from the source array
    
    dst - the destination byte array to write UTF-8 encoded data to
    
    dp - the starting position in the destination array
    
    Returns:
    
    the updated position in the destination array after encoding
  - encodeUTF8
```
public static int encodeUTF8(char[] src,
                             int offset,
                             int len,
                             byte[] dst,
                             int dp)
```
    Encodes a UTF-16 character array to UTF-8 byte array. This method converts characters from a source character array to a destination byte array in UTF-8 encoding format, with optimized handling for ASCII characters.
    
    Parameters:
    
    src - the source character array
    
    offset - the starting offset in the source array
    
    len - the number of characters to encode from the source array
    
    dst - the destination byte array to write UTF-8 encoded data to
    
    dp - the starting position in the destination array
    
    Returns:
    
    the updated position in the destination array after encoding
  - utf8_char2
```
private static void utf8_char2(byte[] src,
                               int offset,
                               int sl,
                               char c,
                               byte[] dst,
                               int dp)
```
  - utf8_char2
```
private static void utf8_char2(char[] src,
                               int offset,
                               int sl,
                               char c,
                               byte[] dst,
                               int dp)
```
  - isNumber
```
public static boolean isNumber(java.lang.String str)
```
    Checks if the given string represents a valid number. A valid number may have an optional leading '+' or '-' sign, followed by one or more digits.
    
    Parameters:
    
    str - the string to check
    
    Returns:
    
    true if the string represents a valid number, false otherwise
  - isNumber
```
public static boolean isNumber(char[] buf,
                               int off,
                               int len)
```
    Checks if the character array segment represents a valid number. A valid number may have an optional leading '+' or '-' sign, followed by one or more digits.
    
    Parameters:
    
    buf - the character array to check
    
    off - the starting offset in the array
    
    len - the number of characters to check
    
    Returns:
    
    true if the character array segment represents a valid number, false otherwise
  - isNumber
```
public static boolean isNumber(byte[] buf,
                               int off,
                               int len)
```
    Checks if the byte array segment represents a valid number. A valid number may have an optional leading '+' or '-' sign, followed by one or more digits.
    
    Parameters:
    
    buf - the byte array to check
    
    off - the starting offset in the array
    
    len - the number of bytes to check
    
    Returns:
    
    true if the byte array segment represents a valid number, false otherwise
  - close
```
public static void close(java.io.Closeable x)
```
    Safely closes a Closeable resource, ignoring any exceptions that may occur. This method is a utility to close resources without having to handle IOException or other exceptions.
    
    Parameters:
    
    x - the Closeable resource to close, can be null
  - decodeUTF8
```
public static int decodeUTF8(byte[] src,
                             int off,
                             int len,
                             byte[] dst)
```
    Decodes UTF-8 encoded byte array to a UTF-16 byte array. This method converts UTF-8 encoded data from a source byte array to UTF-16 encoded data in a destination byte array. Each UTF-16 character is stored as two consecutive bytes.
    
    Parameters:
    
    src - the source byte array containing UTF-8 encoded data
    
    off - the starting offset in the source array
    
    len - the number of bytes to decode from the source array
    
    dst - the destination byte array to write UTF-16 encoded data to
    
    Returns:
    
    the number of bytes written to the destination array, or -1 if decoding fails
  - decodeUTF8
```
public static int decodeUTF8(byte[] src,
                             int off,
                             int len,
                             char[] dst)
```
    Decodes UTF-8 encoded byte array to a character array. This method converts UTF-8 encoded data from a source byte array to Unicode characters in a destination character array, with optimized handling for ASCII characters.
    
    Parameters:
    
    src - the source byte array containing UTF-8 encoded data
    
    off - the starting offset in the source array
    
    len - the number of bytes to decode from the source array
    
    dst - the destination character array to write decoded characters to
    
    Returns:
    
    the number of characters written to the destination array, or -1 if decoding fails
  - lines
```
public static long lines(java.io.File file)
                  throws java.lang.Exception
```
    Counts the number of lines in a file. This method reads the specified file and counts the number of newline characters ('\ ') to determine the total number of lines in the file.
    
    Parameters:
    
    file - the File to count lines in
    
    Returns:
    
    the number of lines in the file
    
    Throws:
    
    java.lang.Exception - if an I/O error occurs while reading the file
  - lines
```
public static long lines(java.io.InputStream in)
                  throws java.lang.Exception
```
    Counts the number of lines in an InputStream. This method reads data from the specified InputStream and counts the number of newline characters ('\ ') to determine the total number of lines in the stream.
    
    Parameters:
    
    in - the InputStream to count lines in
    
    Returns:
    
    the number of lines in the stream
    
    Throws:
    
    java.lang.Exception - if an I/O error occurs while reading the stream
  - writeLocalDate
```
public static int writeLocalDate(byte[] buf,
                                 int off,
                                 int year,
                                 int month,
                                 int dayOfMonth)
```
    Writes a LocalDate value to a byte array in ISO8601 format (yyyy-MM-dd). This method formats a date with year, month, and day components and writes it to the specified byte array buffer at the given offset.
    
    Parameters:
    
    buf - the byte array buffer to write to
    
    off - the offset in the buffer where to start writing
    
    year - the year component of the date
    
    month - the month component of the date (1-12)
    
    dayOfMonth - the day component of the date (1-31)
    
    Returns:
    
    the updated offset after writing the date
  - writeLocalDate
```
public static int writeLocalDate(char[] buf,
                                 int off,
                                 int year,
                                 int month,
                                 int dayOfMonth)
```
    Writes a LocalDate value to a character array in ISO8601 format (yyyy-MM-dd). This method formats a date with year, month, and day components and writes it to the specified character array buffer at the given offset.
    
    Parameters:
    
    buf - the character array buffer to write to
    
    off - the offset in the buffer where to start writing
    
    year - the year component of the date
    
    month - the month component of the date (1-12)
    
    dayOfMonth - the day component of the date (1-31)
    
    Returns:
    
    the updated offset after writing the date
  - writeLocalTime
```
public static void writeLocalTime(byte[] buf,
                                  int off,
                                  int hour,
                                  int minute,
                                  int second)
```
    Writes a LocalTime value to a byte array in ISO8601 format (HH:mm:ss). This method formats a time with hour, minute, and second components and writes it to the specified byte array buffer at the given offset.
    
    Parameters:
    
    buf - the byte array buffer to write to
    
    off - the offset in the buffer where to start writing
    
    hour - the hour component of the time (0-23)
    
    minute - the minute component of the time (0-59)
    
    second - the second component of the time (0-59)
  - writeLocalTime
```
public static int writeLocalTime(byte[] buf,
                                 int off,
                                 java.time.LocalTime time)
```
    Writes a LocalTime value to a byte array in ISO8601 format (HH:mm:ss[.nnnnnnnnn]). This method formats a time with hour, minute, second, and nanosecond components and writes it to the specified byte array buffer at the given offset.
    
    Parameters:
    
    buf - the byte array buffer to write to
    
    off - the offset in the buffer where to start writing
    
    time - the LocalTime object to write
    
    Returns:
    
    the updated offset after writing the time (including nanoseconds if present)
  - writeNano
```
public static int writeNano(byte[] buf,
                            int off,
                            int nano)
```
    Writes nanosecond values to a byte array. This method formats nanosecond values and writes them to the specified byte array buffer at the given offset, typically used for writing fractional seconds in time values.
    
    Parameters:
    
    buf - the byte array buffer to write to
    
    off - the offset in the buffer where to start writing
    
    nano - the nanosecond value to write (0-999,999,999)
    
    Returns:
    
    the updated offset after writing the nanoseconds
  - writeNano
```
public static int writeNano(char[] buf,
                            int off,
                            int nano)
```
    Writes nanosecond values to a character array. This method formats nanosecond values and writes them to the specified character array buffer at the given offset, typically used for writing fractional seconds in time values.
    
    Parameters:
    
    buf - the character array buffer to write to
    
    off - the offset in the buffer where to start writing
    
    nano - the nanosecond value to write (0-999,999,999)
    
    Returns:
    
    the updated offset after writing the nanoseconds
  - writeLocalTime
```
public static void writeLocalTime(char[] buf,
                                  int off,
                                  int hour,
                                  int minute,
                                  int second)
```
    Writes a LocalTime value to a character array in ISO8601 format (HH:mm:ss). This method formats a time with hour, minute, and second components and writes it to the specified character array buffer at the given offset.
    
    Parameters:
    
    buf - the character array buffer to write to
    
    off - the offset in the buffer where to start writing
    
    hour - the hour component of the time (0-23)
    
    minute - the minute component of the time (0-59)
    
    second - the second component of the time (0-59)
  - writeLocalTime
```
public static int writeLocalTime(char[] buf,
                                 int off,
                                 java.time.LocalTime time)
```
    Writes a LocalTime value to a character array in ISO8601 format (HH:mm:ss[.nnnnnnnnn]). This method formats a time with hour, minute, second, and nanosecond components and writes it to the specified character array buffer at the given offset.
    
    Parameters:
    
    buf - the character array buffer to write to
    
    off - the offset in the buffer where to start writing
    
    time - the LocalTime object to write
    
    Returns:
    
    the updated offset after writing the time (including nanoseconds if present)
  - writeInt4
```
private static int writeInt4(byte[] buf,
                             int off,
                             int v)
```
  - writeInt4
```
private static int writeInt4(char[] buf,
                             int off,
                             int v)
```
  - mergeInt64
```
private static long mergeInt64(int v1,
                               int v2)
```
  - writeInt3
```
private static int writeInt3(byte[] buf,
                             int off,
                             int val)
```
  - writeInt3
```
private static int writeInt3(char[] buf,
                             int off,
                             int val)
```
  - writeInt8
```
private static int writeInt8(byte[] buf,
                             int off,
                             int v1,
                             int v2)
```
  - writeInt8
```
private static int writeInt8(char[] buf,
                             int off,
                             int v1,
                             int v2)
```
  - writeInt64
```
public static int writeInt64(byte[] buf,
                             int off,
                             long val)
```
    Writes a 64-bit long integer value to a byte array. This method converts a long integer to its string representation and writes it to the specified byte array buffer at the given offset, handling negative values and optimizing for different value ranges.
    
    Parameters:
    
    buf - the byte array buffer to write to
    
    off - the offset in the buffer where to start writing
    
    val - the long integer value to write
    
    Returns:
    
    the updated offset after writing the value
  - writeInt64
```
public static int writeInt64(char[] buf,
                             int off,
                             long val)
```
    Writes a 64-bit long integer value to a character array. This method converts a long integer to its string representation and writes it to the specified character array buffer at the given offset, handling negative values and optimizing for different value ranges.
    
    Parameters:
    
    buf - the character array buffer to write to
    
    off - the offset in the buffer where to start writing
    
    val - the long integer value to write
    
    Returns:
    
    the updated offset after writing the value
  - writeInt8
```
public static int writeInt8(byte[] buf,
                            int pos,
                            byte value)
```
    Writes an 8-bit byte value as an integer to a byte array. This method converts a byte value to its string representation and writes it to the specified byte array buffer at the given position, handling negative values and optimizing for different value ranges.
    
    Parameters:
    
    buf - the byte array buffer to write to
    
    pos - the position in the buffer where to start writing
    
    value - the byte value to write as an integer
    
    Returns:
    
    the updated position after writing the value
  - writeInt8
```
public static int writeInt8(char[] buf,
                            int pos,
                            byte value)
```
    Writes an 8-bit byte value as an integer to a character array. This method converts a byte value to its string representation and writes it to the specified character array buffer at the given position, handling negative values and optimizing for different value ranges.
    
    Parameters:
    
    buf - the character array buffer to write to
    
    pos - the position in the buffer where to start writing
    
    value - the byte value to write as an integer
    
    Returns:
    
    the updated position after writing the value
  - writeInt16
```
public static int writeInt16(byte[] buf,
                             int pos,
                             short value)
```
    Writes a 16-bit short value as an integer to a byte array. This method converts a short value to its string representation and writes it to the specified byte array buffer at the given position, handling negative values and optimizing for different value ranges.
    
    Parameters:
    
    buf - the byte array buffer to write to
    
    pos - the position in the buffer where to start writing
    
    value - the short value to write as an integer
    
    Returns:
    
    the updated position after writing the value
  - writeInt16
```
public static int writeInt16(char[] buf,
                             int pos,
                             short value)
```
    Writes a 16-bit short value as an integer to a character array. This method converts a short value to its string representation and writes it to the specified character array buffer at the given position, handling negative values and optimizing for different value ranges.
    
    Parameters:
    
    buf - the character array buffer to write to
    
    pos - the position in the buffer where to start writing
    
    value - the short value to write as an integer
    
    Returns:
    
    the updated position after writing the value
  - writeInt32
```
public static int writeInt32(byte[] buf,
                             int off,
                             long val)
```
    Writes a 32-bit integer value to a byte array. This method converts a long value to its string representation and writes it to the specified byte array buffer at the given offset, handling negative values and optimizing for different value ranges.
    
    Parameters:
    
    buf - the byte array buffer to write to
    
    off - the offset in the buffer where to start writing
    
    val - the long value to write as an integer
    
    Returns:
    
    the updated offset after writing the value
  - writeInt32
```
public static int writeInt32(char[] buf,
                             int off,
                             long val)
```
    Writes a 32-bit integer value to a character array. This method converts a long value to its string representation and writes it to the specified character array buffer at the given offset, handling negative values and optimizing for different value ranges.
    
    Parameters:
    
    buf - the character array buffer to write to
    
    off - the offset in the buffer where to start writing
    
    val - the long value to write as an integer
    
    Returns:
    
    the updated offset after writing the value
  - getByte
```
public static byte getByte(byte[] buf,
                           int pos)
```
    Gets a byte value from a byte array at the specified position. This method retrieves a byte value from the specified byte array at the given position using unsafe memory operations for improved performance.
    
    Parameters:
    
    buf - the byte array buffer to read from
    
    pos - the position in the buffer where to read the byte value
    
    Returns:
    
    the byte value at the specified position
  - getChar
```
public static char getChar(char[] buf,
                           int pos)
```
    Gets a character value from a character array at the specified position. This method retrieves a character value from the specified character array at the given position using unsafe memory operations for improved performance.
    
    Parameters:
    
    buf - the character array buffer to read from
    
    pos - the position in the buffer where to read the character value
    
    Returns:
    
    the character value at the specified position
  - getChar
```
public static char getChar(byte[] buf,
                           int pos)
```
    Gets a character value from a byte array at the specified position. This method retrieves a character value from the specified byte array at the given position using unsafe memory operations for improved performance.
    
    Parameters:
    
    buf - the byte array buffer to read from
    
    pos - the position in the buffer where to read the character value
    
    Returns:
    
    the character value at the specified position
  - putByte
```
private static void putByte(byte[] buf,
                            int pos,
                            byte v)
```
  - putChar
```
private static void putChar(char[] buf,
                            int pos,
                            char v)
```
  - putShortBE
```
public static void putShortBE(byte[] buf,
                              int pos,
                              short v)
```
    Writes a short value to a byte array in big-endian byte order. This method puts a short value into the specified byte array at the given position using big-endian byte ordering (most significant byte first).
    
    Parameters:
    
    buf - the byte array buffer to write to
    
    pos - the position in the buffer where to write the short value
    
    v - the short value to write
  - putShortLE
```
public static void putShortLE(byte[] buf,
                              int pos,
                              short v)
```
    Writes a short value to a byte array in little-endian byte order. This method puts a short value into the specified byte array at the given position using little-endian byte ordering (least significant byte first).
    
    Parameters:
    
    buf - the byte array buffer to write to
    
    pos - the position in the buffer where to write the short value
    
    v - the short value to write
  - putIntBE
```
public static void putIntBE(byte[] buf,
                            int pos,
                            int v)
```
    Writes an int value to a byte array in big-endian byte order. This method puts an int value into the specified byte array at the given position using big-endian byte ordering (most significant byte first).
    
    Parameters:
    
    buf - the byte array buffer to write to
    
    pos - the position in the buffer where to write the int value
    
    v - the int value to write
  - putIntLE
```
public static void putIntLE(byte[] buf,
                            int pos,
                            int v)
```
    Writes an int value to a byte array in little-endian byte order. This method puts an int value into the specified byte array at the given position using little-endian byte ordering (least significant byte first).
    
    Parameters:
    
    buf - the byte array buffer to write to
    
    pos - the position in the buffer where to write the int value
    
    v - the int value to write
  - putIntLE
```
public static void putIntLE(char[] buf,
                            int pos,
                            int v)
```
    Writes an int value to a character array in little-endian byte order. This method puts an int value into the specified character array at the given position using little-endian byte ordering (least significant byte first).
    
    Parameters:
    
    buf - the character array buffer to write to
    
    pos - the position in the buffer where to write the int value
    
    v - the int value to write
  - putShortUnaligned
```
public static void putShortUnaligned(byte[] buf,
                                     int pos,
                                     short v)
```
    Writes a short value to a byte array without alignment considerations. This method puts a short value into the specified byte array at the given position without performing any byte order conversion or alignment adjustments.
    
    Parameters:
    
    buf - the byte array buffer to write to
    
    pos - the position in the buffer where to write the short value
    
    v - the short value to write
  - putIntUnaligned
```
public static void putIntUnaligned(char[] buf,
                                   int pos,
                                   int v)
```
    Writes an int value to a character array without alignment considerations. This method puts an int value into the specified character array at the given position without performing any byte order conversion or alignment adjustments.
    
    Parameters:
    
    buf - the character array buffer to write to
    
    pos - the position in the buffer where to write the int value
    
    v - the int value to write
  - putIntUnaligned
```
public static void putIntUnaligned(byte[] buf,
                                   int pos,
                                   int v)
```
    Writes an int value to a byte array without alignment considerations. This method puts an int value into the specified byte array at the given position without performing any byte order conversion or alignment adjustments.
    
    Parameters:
    
    buf - the byte array buffer to write to
    
    pos - the position in the buffer where to write the int value
    
    v - the int value to write
  - putLongLE
```
public static void putLongLE(char[] buf,
                             int pos,
                             long v)
```
    Writes a long value to a character array in little-endian byte order. This method puts a long value into the specified character array at the given position using little-endian byte ordering (least significant byte first).
    
    Parameters:
    
    buf - the character array buffer to write to
    
    pos - the position in the buffer where to write the long value
    
    v - the long value to write
  - putLongUnaligned
```
public static void putLongUnaligned(char[] buf,
                                    int pos,
                                    long v)
```
    Writes a long value to a character array without alignment considerations. This method puts a long value into the specified character array at the given position without performing any byte order conversion or alignment adjustments.
    
    Parameters:
    
    buf - the character array buffer to write to
    
    pos - the position in the buffer where to write the long value
    
    v - the long value to write
  - putLongUnaligned
```
public static void putLongUnaligned(byte[] buf,
                                    int pos,
                                    long v)
```
    Writes a long value to a byte array without alignment considerations. This method puts a long value into the specified byte array at the given position without performing any byte order conversion or alignment adjustments.
    
    Parameters:
    
    buf - the byte array buffer to write to
    
    pos - the position in the buffer where to write the long value
    
    v - the long value to write
  - putLongBE
```
public static void putLongBE(byte[] buf,
                             int pos,
                             long v)
```
    Writes a long value to a byte array in big-endian byte order. This method puts a long value into the specified byte array at the given position using big-endian byte ordering (most significant byte first).
    
    Parameters:
    
    buf - the byte array buffer to write to
    
    pos - the position in the buffer where to write the long value
    
    v - the long value to write
  - putLongLE
```
public static void putLongLE(byte[] buf,
                             int pos,
                             long v)
```
    Writes a long value to a byte array in little-endian byte order. This method puts a long value into the specified byte array at the given position using little-endian byte ordering (least significant byte first).
    
    Parameters:
    
    buf - the byte array buffer to write to
    
    pos - the position in the buffer where to write the long value
    
    v - the long value to write
  - putBoolean
```
public static int putBoolean(byte[] buf,
                             int off,
                             boolean v)
```
    Writes a boolean value to a byte array as a string representation. This method writes either "true" or "false" to the specified byte array at the given offset. For true values, it writes "true" (4 bytes), and for false values, it writes "false" (5 bytes).
    
    Parameters:
    
    buf - the byte array buffer to write to
    
    off - the offset in the buffer where to start writing
    
    v - the boolean value to write
    
    Returns:
    
    the updated offset after writing the boolean value
  - putBoolean
```
public static int putBoolean(char[] buf,
                             int off,
                             boolean v)
```
    Writes a boolean value to a character array as a string representation. This method writes either "true" or "false" to the specified character array at the given offset. For true values, it writes "true" (4 characters), and for false values, it writes "false" (5 characters).
    
    Parameters:
    
    buf - the character array buffer to write to
    
    off - the offset in the buffer where to start writing
    
    v - the boolean value to write
    
    Returns:
    
    the updated offset after writing the boolean value
  - isALSE
```
public static boolean isALSE(byte[] buf,
                             int pos)
```
    Checks if the specified position in a byte array contains the string "alse". This method is used to verify if a byte sequence matches the "alse" portion of "false".
    
    Parameters:
    
    buf - the byte array buffer to check
    
    pos - the position in the buffer to check
    
    Returns:
    
    true if the position contains "alse", false otherwise
  - notALSE
```
public static boolean notALSE(byte[] buf,
                              int pos)
```
    Checks if the specified position in a byte array does not contain the string "alse". This method is used to verify if a byte sequence does not match the "alse" portion of "false".
    
    Parameters:
    
    buf - the byte array buffer to check
    
    pos - the position in the buffer to check
    
    Returns:
    
    true if the position does not contain "alse", false otherwise
  - isALSE
```
public static boolean isALSE(char[] buf,
                             int pos)
```
    Checks if the specified position in a character array contains the string "alse". This method is used to verify if a character sequence matches the "alse" portion of "false".
    
    Parameters:
    
    buf - the character array buffer to check
    
    pos - the position in the buffer to check
    
    Returns:
    
    true if the position contains "alse", false otherwise
  - notALSE
```
public static boolean notALSE(char[] buf,
                              int pos)
```
    Checks if the specified position in a character array does not contain the string "alse". This method is used to verify if a character sequence does not match the "alse" portion of "false".
    
    Parameters:
    
    buf - the character array buffer to check
    
    pos - the position in the buffer to check
    
    Returns:
    
    true if the position does not contain "alse", false otherwise
  - isNULL
```
public static boolean isNULL(byte[] buf,
                             int pos)
```
    Checks if the specified position in a byte array contains the string "null". This method is used to verify if a byte sequence matches the string "null".
    
    Parameters:
    
    buf - the byte array buffer to check
    
    pos - the position in the buffer to check
    
    Returns:
    
    true if the position contains "null", false otherwise
  - notNULL
```
public static boolean notNULL(byte[] buf,
                              int pos)
```
    Checks if the specified position in a byte array does not contain the string "null". This method is used to verify if a byte sequence does not match the string "null".
    
    Parameters:
    
    buf - the byte array buffer to check
    
    pos - the position in the buffer to check
    
    Returns:
    
    true if the position does not contain "null", false otherwise
  - notTRUE
```
public static boolean notTRUE(byte[] buf,
                              int pos)
```
    Checks if the specified position in a byte array does not contain the string "true". This method is used to verify if a byte sequence does not match the string "true".
    
    Parameters:
    
    buf - the byte array buffer to check
    
    pos - the position in the buffer to check
    
    Returns:
    
    true if the position does not contain "true", false otherwise
  - notTRUE
```
public static boolean notTRUE(char[] buf,
                              int pos)
```
    Checks if the specified position in a character array does not contain the string "true". This method is used to verify if a character sequence does not match the string "true".
    
    Parameters:
    
    buf - the character array buffer to check
    
    pos - the position in the buffer to check
    
    Returns:
    
    true if the position does not contain "true", false otherwise
  - isNULL
```
public static boolean isNULL(char[] buf,
                             int pos)
```
    Checks if the specified position in a character array contains the string "null". This method is used to verify if a character sequence matches the string "null".
    
    Parameters:
    
    buf - the character array buffer to check
    
    pos - the position in the buffer to check
    
    Returns:
    
    true if the position contains "null", false otherwise
  - notNULL
```
public static boolean notNULL(char[] buf,
                              int pos)
```
    Checks if the specified position in a character array does not contain the string "null". This method is used to verify if a character sequence does not match the string "null".
    
    Parameters:
    
    buf - the character array buffer to check
    
    pos - the position in the buffer to check
    
    Returns:
    
    true if the position does not contain "null", false otherwise
  - putNULL
```
public static void putNULL(byte[] buf,
                           int pos)
```
    Writes the string "null" to a byte array at the specified position. This method puts the byte representation of "null" into the specified byte array at the given position.
    
    Parameters:
    
    buf - the byte array buffer to write to
    
    pos - the position in the buffer where to write "null"
  - putNULL
```
public static void putNULL(char[] buf,
                           int pos)
```
    Writes the string "null" to a character array at the specified position. This method puts the character representation of "null" into the specified character array at the given position.
    
    Parameters:
    
    buf - the character array buffer to write to
    
    pos - the position in the buffer where to write "null"
  - digit4
```
public static int digit4(char[] buf,
                         int off)
```
    Extracts a 4-digit number from a character array at the specified offset. This method performs optimized digit extraction by processing 4 characters at once using vector operations for improved performance.
    
    Parameters:
    
    buf - the character array to extract digits from
    
    off - the offset in the array where to start extracting
    
    Returns:
    
    the extracted 4-digit number, or -1 if the characters are not valid digits
  - digit4
```
public static int digit4(byte[] buf,
                         int off)
```
    Extracts a 4-digit number from a byte array at the specified offset. This method performs optimized digit extraction by processing 4 bytes at once using vector operations for improved performance.
    
    Parameters:
    
    buf - the byte array to extract digits from
    
    off - the offset in the array where to start extracting
    
    Returns:
    
    the extracted 4-digit number, or -1 if the bytes are not valid digits
  - digit4
```
private static int digit4(int x)
```
    Extracts a 4-digit number from an integer value. This method performs optimized digit extraction on a packed integer containing 4 digits using vector operations for improved performance.
    
    Parameters:
    
    x - the integer containing packed digit information
    
    Returns:
    
    the extracted 4-digit number, or -1 if the value does not contain valid digits
  - digit3
```
public static int digit3(char[] buf,
                         int off)
```
    Extracts a 3-digit number from a character array at the specified offset. This method performs optimized digit extraction by processing 3 characters at once using vector operations for improved performance.
    
    Parameters:
    
    buf - the character array to extract digits from
    
    off - the offset in the array where to start extracting
    
    Returns:
    
    the extracted 3-digit number, or -1 if the characters are not valid digits
  - digit3
```
public static int digit3(byte[] buf,
                         int off)
```
    Extracts a 3-digit number from a byte array at the specified offset. This method performs optimized digit extraction by processing 3 bytes at once using vector operations for improved performance.
    
    Parameters:
    
    buf - the byte array to extract digits from
    
    off - the offset in the array where to start extracting
    
    Returns:
    
    the extracted 3-digit number, or -1 if the bytes are not valid digits
  - digit3
```
private static int digit3(int x)
```
    Extracts a 3-digit number from an integer value. This method performs optimized digit extraction on a packed integer containing 3 digits using vector operations for improved performance.
    
    Parameters:
    
    x - the integer containing packed digit information
    
    Returns:
    
    the extracted 3-digit number, or -1 if the value does not contain valid digits
  - digit2
```
public static int digit2(char[] buf,
                         int off)
```
    Extracts a 2-digit number from a character array at the specified offset. This method performs optimized digit extraction by processing 2 characters at once using vector operations for improved performance.
    
    Parameters:
    
    buf - the character array to extract digits from
    
    off - the offset in the array where to start extracting
    
    Returns:
    
    the extracted 2-digit number, or -1 if the characters are not valid digits
  - digit2
```
public static int digit2(byte[] buf,
                         int off)
```
    Extracts a 2-digit number from a byte array at the specified offset. This method performs optimized digit extraction by processing 2 bytes at once using vector operations for improved performance.
    
    Parameters:
    
    buf - the byte array to extract digits from
    
    off - the offset in the array where to start extracting
    
    Returns:
    
    the extracted 2-digit number, or -1 if the bytes are not valid digits
  - isDigit2
```
public static boolean isDigit2(char[] buf,
                               int off)
```
    Checks if the 2 characters at the specified offset in a character array represent valid digits. This method performs optimized digit validation by processing 2 characters at once using vector operations for improved performance.
    
    Parameters:
    
    buf - the character array to check
    
    off - the offset in the array where to start checking
    
    Returns:
    
    true if both characters represent valid digits (0-9), false otherwise
  - digit
```
public static int digit(int d)
```
    Validates if the specified integer value represents a single digit (0-9). This method checks if the input value is within the valid digit range.
    
    Parameters:
    
    d - the integer value to check
    
    Returns:
    
    the input value if it's a valid digit (0-9), -1 otherwise
  - digit1
```
public static int digit1(char[] buf,
                         int off)
```
    Extracts a single digit from a character array at the specified offset. This method performs optimized digit extraction for a single character.
    
    Parameters:
    
    buf - the character array to extract the digit from
    
    off - the offset in the array where to extract the digit
    
    Returns:
    
    the extracted digit value (0-9), or -1 if the character is not a valid digit
  - digit1
```
public static int digit1(byte[] buf,
                         int off)
```
    Extracts a single digit from a byte array at the specified offset. This method performs optimized digit extraction for a single byte.
    
    Parameters:
    
    buf - the byte array to extract the digit from
    
    off - the offset in the array where to extract the digit
    
    Returns:
    
    the extracted digit value (0-9), or -1 if the byte is not a valid digit
  - indexOfQuote
```
public static int indexOfQuote(byte[] buf,
                               int quote,
                               int fromIndex,
                               int max)
```
    Finds the index of a quote character in a byte array. This method searches for either a single quote (') or double quote (") character within the specified range of the byte array.
    
    Parameters:
    
    buf - the byte array to search in
    
    quote - the quote character to search for (either '\'' or '"')
    
    fromIndex - the index to start searching from
    
    max - the maximum index to search up to (exclusive)
    
    Returns:
    
    the index of the quote character, or -1 if not found
  - indexOfQuoteV
```
public static int indexOfQuoteV(byte[] buf,
                                int quote,
                                int fromIndex,
                                int max)
```
    Finds the index of a quote character in a byte array using vectorized operations. This method searches for either a single quote (') or double quote (") character within the specified range of the byte array using optimized vector operations.
    
    Parameters:
    
    buf - the byte array to search in
    
    quote - the quote character to search for (either '\'' or '"')
    
    fromIndex - the index to start searching from
    
    max - the maximum index to search up to (exclusive)
    
    Returns:
    
    the index of the quote character, or -1 if not found
  - indexOfDoubleQuote
```
public static int indexOfDoubleQuote(byte[] buf,
                                     int fromIndex,
                                     int max)
```
    Finds the index of a double quote character in a byte array. This method searches for a double quote (") character within the specified range of the byte array.
    
    Parameters:
    
    buf - the byte array to search in
    
    fromIndex - the index to start searching from
    
    max - the maximum index to search up to (exclusive)
    
    Returns:
    
    the index of the double quote character, or -1 if not found
  - indexOfDoubleQuoteV
```
public static int indexOfDoubleQuoteV(byte[] buf,
                                      int fromIndex,
                                      int max)
```
    Finds the index of a double quote character in a byte array using vectorized operations. This method searches for a double quote (") character within the specified range of the byte array using optimized vector operations.
    
    Parameters:
    
    buf - the byte array to search in
    
    fromIndex - the index to start searching from
    
    max - the maximum index to search up to (exclusive)
    
    Returns:
    
    the index of the double quote character, or -1 if not found
  - indexOfLineSeparator
```
public static int indexOfLineSeparator(byte[] buf,
                                       int fromIndex,
                                       int max)
```
    Finds the index of a line separator character in a byte array. This method searches for a newline ('\n') character within the specified range of the byte array.
    
    Parameters:
    
    buf - the byte array to search in
    
    fromIndex - the index to start searching from
    
    max - the maximum index to search up to (exclusive)
    
    Returns:
    
    the index of the line separator character, or -1 if not found
  - indexOfLineSeparatorV
```
public static int indexOfLineSeparatorV(byte[] buf,
                                        int fromIndex,
                                        int max)
```
    Finds the index of a line separator character in a byte array using vectorized operations. This method searches for a newline ('\n') character within the specified range of the byte array using optimized vector operations.
    
    Parameters:
    
    buf - the byte array to search in
    
    fromIndex - the index to start searching from
    
    max - the maximum index to search up to (exclusive)
    
    Returns:
    
    the index of the line separator character, or -1 if not found
  - indexOfSlash
```
public static int indexOfSlash(byte[] buf,
                               int fromIndex,
                               int max)
```
    Finds the index of a slash character in a byte array. This method searches for a backslash ('\') character within the specified range of the byte array.
    
    Parameters:
    
    buf - the byte array to search in
    
    fromIndex - the index to start searching from
    
    max - the maximum index to search up to (exclusive)
    
    Returns:
    
    the index of the slash character, or -1 if not found
  - indexOfSlashV
```
public static int indexOfSlashV(byte[] buf,
                                int fromIndex,
                                int max)
```
    Finds the index of a slash character in a byte array using vectorized operations. This method searches for a backslash ('\') character within the specified range of the byte array using optimized vector operations.
    
    Parameters:
    
    buf - the byte array to search in
    
    fromIndex - the index to start searching from
    
    max - the maximum index to search up to (exclusive)
    
    Returns:
    
    the index of the slash character, or -1 if not found
  - regionMatches
```
public static boolean regionMatches(byte[] bytes,
                                    int off,
                                    java.lang.String prefix)
```
    Checks if a byte array region matches a prefix string. This method compares a segment of a byte array with a string prefix to see if they match exactly.
    
    Parameters:
    
    bytes - the byte array to check
    
    off - the offset in the byte array where to start checking
    
    prefix - the string prefix to match against
    
    Returns:
    
    true if the byte array region matches the prefix, false otherwise
  - indexOfChar
```
public static int indexOfChar(byte[] buf,
                              int ch,
                              int fromIndex,
                              int max)
```
    Finds the index of a character in a byte array. This method searches for a specific character within the specified range of the byte array.
    
    Parameters:
    
    buf - the byte array to search in
    
    ch - the character to search for
    
    fromIndex - the index to start searching from
    
    max - the maximum index to search up to (exclusive)
    
    Returns:
    
    the index of the character, or -1 if not found
  - indexOfChar
```
public static int indexOfChar(char[] buf,
                              int ch,
                              int fromIndex,
                              int max)
```
    Finds the index of a character in a character array. This method searches for a specific character within the specified range of the character array.
    
    Parameters:
    
    buf - the character array to search in
    
    ch - the character to search for
    
    fromIndex - the index to start searching from
    
    max - the maximum index to search up to (exclusive)
    
    Returns:
    
    the index of the character, or -1 if not found
  - notContains
```
private static boolean notContains(long value,
                                   long vector)
```
  - hexDigit4
```
public static int hexDigit4(byte[] buf,
                            int offset,
                            int end)
```
  - outOfBoundsCheckFromToIndex
```
static JSONException outOfBoundsCheckFromToIndex(int offset,
                                                 int end)
```
  - hexDigit4
```
public static int hexDigit4(byte[] buf,
                            int offset)
```
    Extracts a 4-digit hexadecimal number from a byte array at the specified offset. This method performs optimized hexadecimal digit extraction by processing 4 bytes at once using vector operations for improved performance.
    
    Parameters:
    
    buf - the byte array to extract hexadecimal digits from
    
    offset - the offset in the array where to start extracting
    
    Returns:
    
    the extracted 4-digit hexadecimal number
  - hexDigit4
```
public static int hexDigit4(char[] buf,
                            int offset,
                            int end)
```
  - hexDigit4
```
public static int hexDigit4(char[] buf,
                            int offset)
```
    Extracts a 4-digit hexadecimal number from a character array at the specified offset. This method performs optimized hexadecimal digit extraction by processing 4 characters at once using vector operations for improved performance.
    
    Parameters:
    
    buf - the character array to extract hexadecimal digits from
    
    offset - the offset in the array where to start extracting
    
    Returns:
    
    the extracted 4-digit hexadecimal number
  - isDigit
```
public static boolean isDigit(int ch)
```
    Checks if the specified character is a digit (0-9). This method determines if a character represents a valid decimal digit.
    
    Parameters:
    
    ch - the character to check
    
    Returns:
    
    true if the character is a digit (0-9), false otherwise
  - getShortUnaligned
```
public static short getShortUnaligned(byte[] buf,
                                      int offset)
```
    Gets a short value from a byte array at the specified offset without alignment considerations. This method retrieves a short value from the specified byte array at the given offset without performing any byte order conversion or alignment adjustments.
    
    Parameters:
    
    buf - the byte array to read from
    
    offset - the offset in the array where to read the short value
    
    Returns:
    
    the short value at the specified offset
  - getShortBE
```
public static short getShortBE(byte[] buf,
                               int offset)
```
    Gets a short value from a byte array at the specified offset in big-endian byte order. This method retrieves a short value from the specified byte array at the given offset using big-endian byte ordering (most significant byte first).
    
    Parameters:
    
    buf - the byte array to read from
    
    offset - the offset in the array where to read the short value
    
    Returns:
    
    the short value at the specified offset in big-endian order
  - getShortLE
```
public static short getShortLE(byte[] buf,
                               int offset)
```
    Gets a short value from a byte array at the specified offset in little-endian byte order. This method retrieves a short value from the specified byte array at the given offset using little-endian byte ordering (least significant byte first).
    
    Parameters:
    
    buf - the byte array to read from
    
    offset - the offset in the array where to read the short value
    
    Returns:
    
    the short value at the specified offset in little-endian order
  - isUTF8BOM
```
public static boolean isUTF8BOM(byte[] buf,
                                int off)
```
    Checks if the specified position in a byte array contains a UTF-8 Byte Order Mark (BOM). This method verifies if the first three bytes at the specified offset match the UTF-8 BOM sequence (0xEF, 0xBB, 0xBF).
    
    Parameters:
    
    buf - the byte array to check
    
    off - the offset in the array where to check for the BOM
    
    Returns:
    
    true if the position contains a UTF-8 BOM, false otherwise
  - getIntBE
```
public static int getIntBE(byte[] buf,
                           int offset)
```
    Gets an int value from a byte array at the specified offset in big-endian byte order. This method retrieves an int value from the specified byte array at the given offset using big-endian byte ordering (most significant byte first).
    
    Parameters:
    
    buf - the byte array to read from
    
    offset - the offset in the array where to read the int value
    
    Returns:
    
    the int value at the specified offset in big-endian order
  - getIntLE
```
public static int getIntLE(byte[] buf,
                           int offset)
```
    Gets an int value from a byte array at the specified offset in little-endian byte order. This method retrieves an int value from the specified byte array at the given offset using little-endian byte ordering (least significant byte first).
    
    Parameters:
    
    buf - the byte array to read from
    
    offset - the offset in the array where to read the int value
    
    Returns:
    
    the int value at the specified offset in little-endian order
  - getIntLE
```
public static int getIntLE(char[] buf,
                           int offset)
```
    Gets an int value from a character array at the specified offset in little-endian byte order. This method retrieves an int value from the specified character array at the given offset using little-endian byte ordering (least significant byte first).
    
    Parameters:
    
    buf - the character array to read from
    
    offset - the offset in the array where to read the int value
    
    Returns:
    
    the int value at the specified offset in little-endian order
  - getIntUnaligned
```
public static int getIntUnaligned(byte[] buf,
                                  int offset)
```
    Gets an int value from a byte array at the specified offset without alignment considerations. This method retrieves an int value from the specified byte array at the given offset without performing any byte order conversion or alignment adjustments.
    
    Parameters:
    
    buf - the byte array to read from
    
    offset - the offset in the array where to read the int value
    
    Returns:
    
    the int value at the specified offset
  - getIntUnaligned
```
public static int getIntUnaligned(char[] buf,
                                  int offset)
```
    Gets an int value from a character array at the specified offset without alignment considerations. This method retrieves an int value from the specified character array at the given offset without performing any byte order conversion or alignment adjustments.
    
    Parameters:
    
    buf - the character array to read from
    
    offset - the offset in the array where to read the int value
    
    Returns:
    
    the int value at the specified offset
  - getLongBE
```
public static long getLongBE(byte[] buf,
                             int offset)
```
    Gets a long value from a byte array at the specified offset in big-endian byte order. This method retrieves a long value from the specified byte array at the given offset using big-endian byte ordering (most significant byte first).
    
    Parameters:
    
    buf - the byte array to read from
    
    offset - the offset in the array where to read the long value
    
    Returns:
    
    the long value at the specified offset in big-endian order
  - getLongUnaligned
```
public static long getLongUnaligned(byte[] buf,
                                    int offset)
```
    Gets a long value from a byte array at the specified offset without alignment considerations. This method retrieves a long value from the specified byte array at the given offset without performing any byte order conversion or alignment adjustments.
    
    Parameters:
    
    buf - the byte array to read from
    
    offset - the offset in the array where to read the long value
    
    Returns:
    
    the long value at the specified offset
  - getLongUnaligned
```
public static long getLongUnaligned(char[] buf,
                                    int offset)
```
    Gets a long value from a character array at the specified offset without alignment considerations. This method retrieves a long value from the specified character array at the given offset without performing any byte order conversion or alignment adjustments.
    
    Parameters:
    
    buf - the character array to read from
    
    offset - the offset in the array where to read the long value
    
    Returns:
    
    the long value at the specified offset
  - getLongLE
```
public static long getLongLE(byte[] buf,
                             int offset)
```
    Gets a long value from a byte array at the specified offset in little-endian byte order. This method retrieves a long value from the specified byte array at the given offset using little-endian byte ordering (least significant byte first).
    
    Parameters:
    
    buf - the byte array to read from
    
    offset - the offset in the array where to read the long value
    
    Returns:
    
    the long value at the specified offset in little-endian order
  - getLongLE
```
public static long getLongLE(char[] buf,
                             int offset)
```
    Gets a long value from a character array at the specified offset in little-endian byte order. This method retrieves a long value from the specified character array at the given offset using little-endian byte ordering (least significant byte first).
    
    Parameters:
    
    buf - the character array to read from
    
    offset - the offset in the array where to read the long value
    
    Returns:
    
    the long value at the specified offset in little-endian order
  - hex2
```
public static short hex2(int i)
```
    Converts a 2-digit hexadecimal value to its character representation. This method transforms a packed 2-digit hexadecimal value into its ASCII character representation using optimized bit operations.
    
    Parameters:
    
    i - the packed 2-digit hexadecimal value to convert
    
    Returns:
    
    the character representation of the hexadecimal value
  - hex2U
```
public static short hex2U(int i)
```
    Converts a 2-digit hexadecimal value to its uppercase character representation. This method transforms a packed 2-digit hexadecimal value into its uppercase ASCII character representation using optimized bit operations.
    
    Parameters:
    
    i - the packed 2-digit hexadecimal value to convert
    
    Returns:
    
    the uppercase character representation of the hexadecimal value
  - utf16Hex2
```
public static int utf16Hex2(int i)
```
    Converts a 2-digit hexadecimal value to its UTF-16 character representation. This method transforms a packed 2-digit hexadecimal value into its UTF-16 character representation using optimized bit operations.
    
    Parameters:
    
    i - the packed 2-digit hexadecimal value to convert
    
    Returns:
    
    the UTF-16 character representation of the hexadecimal value
  - hex4U
```
public static int hex4U(int i)
```
    Converts a 4-digit hexadecimal value to its uppercase character representation. This method transforms a packed 4-digit hexadecimal value into its uppercase ASCII character representation using optimized bit operations.
    
    Parameters:
    
    i - the packed 4-digit hexadecimal value to convert
    
    Returns:
    
    the uppercase character representation of the hexadecimal value
  - utf16Hex4U
```
public static long utf16Hex4U(long i)
```
    Converts a 4-digit hexadecimal value to its uppercase UTF-16 character representation. This method transforms a packed 4-digit hexadecimal value into its uppercase UTF-16 character representation using optimized bit operations.
    
    Parameters:
    
    i - the packed 4-digit hexadecimal value to convert
    
    Returns:
    
    the uppercase UTF-16 character representation of the hexadecimal value
  - reverseBytesExpand
```
private static int reverseBytesExpand(int i)
```
  - utf16ReverseBytesExpand
```
private static long utf16ReverseBytesExpand(long i)
```
  - convEndian
```
public static int convEndian(boolean big,
                             int n)
```
    Converts an integer value between big-endian and little-endian byte orders. This method conditionally reverses the byte order of an integer value based on the specified endianness flag and the system's native endianness.
    
    Parameters:
    
    big - true to convert to big-endian, false to convert to little-endian
    
    n - the integer value to convert
    
    Returns:
    
    the converted integer value in the specified byte order
  - convEndian
```
public static long convEndian(boolean big,
                              long n)
```
    Converts a long value between big-endian and little-endian byte orders. This method conditionally reverses the byte order of a long value based on the specified endianness flag and the system's native endianness.
    
    Parameters:
    
    big - true to convert to big-endian, false to convert to little-endian
    
    n - the long value to convert
    
    Returns:
    
    the converted long value in the specified byte order
  - convEndian
```
static short convEndian(boolean big,
                        short n)
```
  - isLatin1
```
public static boolean isLatin1(char[] buf,
                               int off,
                               int len)
```
    Checks if a character array segment contains only Latin-1 characters. This method verifies that all characters in the specified segment of the character array are within the Latin-1 character set (Unicode code points 0-255).
    
    Parameters:
    
    buf - the character array to check
    
    off - the starting offset in the array
    
    len - the number of characters to check
    
    Returns:
    
    true if all characters in the segment are Latin-1, false otherwise
  - isASCII
```
public static boolean isASCII(java.lang.String str)
```
    Checks if a string contains only ASCII characters. This method verifies that all characters in the specified string are within the ASCII character set (Unicode code points 0-127).
    
    Parameters:
    
    str - the string to check
    
    Returns:
    
    true if all characters in the string are ASCII, false otherwise
  - isASCII
```
public static boolean isASCII(byte[] buf)
```
    Checks if a byte array contains only ASCII characters. This method verifies that all bytes in the specified byte array are within the ASCII character set (values 0-127).
    
    Parameters:
    
    buf - the byte array to check
    
    Returns:
    
    true if all bytes in the array are ASCII, false otherwise
  - isASCII
```
public static boolean isASCII(byte[] buf,
                              int off,
                              int len)
```
    Checks if a byte array segment contains only ASCII characters. This method verifies that all bytes in the specified segment of the byte array are within the ASCII character set (values 0-127).
    
    Parameters:
    
    buf - the byte array to check
    
    off - the starting offset in the array
    
    len - the number of bytes to check
    
    Returns:
    
    true if all bytes in the segment are ASCII, false otherwise
  - isNonSlashASCII
```
public static boolean isNonSlashASCII(byte[] buf,
                                      int off,
                                      int len)
```
    Checks if a byte array segment contains only ASCII characters and no backslash characters. This method verifies that all bytes in the specified segment of the byte array are within the ASCII character set (values 0-127) and do not contain any backslash ('\\') characters.
    
    Parameters:
    
    buf - the byte array to check
    
    off - the starting offset in the array
    
    len - the number of bytes to check
    
    Returns:
    
    true if all bytes in the segment are ASCII and not backslashes, false otherwise
  - isDigitLatin1
```
private static boolean isDigitLatin1(int c)
```
  - parseInt
```
public static int parseInt(byte[] buf,
                           int off,
                           int len)
```
    Parses an integer value from a byte array segment. This method converts a sequence of ASCII digit characters in a byte array segment to an integer value, handling optional leading '+' or '-' signs.
    
    Parameters:
    
    buf - the byte array containing the digit characters
    
    off - the starting offset in the array
    
    len - the number of bytes to parse
    
    Returns:
    
    the parsed integer value
    
    Throws:
    
    java.lang.NumberFormatException - if the byte array segment does not contain a valid integer representation

Class IOUtils

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

DOT_ZERO_16

DOT_ZERO_32

ZERO_DOT_16

ZERO_DOT_32

ZERO_ZERO_16

ZERO_ZERO_32

NULL_32

NULL_64

TRUE

TRUE_64

ALSE

ALSE_64

DOT_X0

sizeTable

DIGITS_K_32

DIGITS_K_64

MIN_LONG_BYTES

MIN_LONG_CHARS

PACKED_DIGITS

PACKED_DIGITS_UTF16

POWER_TEN

ZERO_DOT_LATIN1

Constructor Detail

IOUtils

Method Detail

digitPair

writeDigitPair

writeDigitPair

stringSize

stringSize

getChars

getChars

getChars

getChars

writeDecimal

writeDecimal

encodeUTF8

encodeUTF8

utf8_char2

utf8_char2

isNumber

isNumber

isNumber

close

decodeUTF8

decodeUTF8

lines

lines

writeLocalDate

writeLocalDate

writeLocalTime

writeLocalTime

writeNano

writeNano

writeLocalTime

writeLocalTime

writeInt4

writeInt4

mergeInt64

writeInt3

writeInt3

writeInt8

writeInt8

writeInt64

writeInt64

writeInt8

writeInt8

writeInt16

writeInt16

writeInt32

writeInt32

getByte

getChar

getChar