## org.h2.util
Class Utils

    java.lang.Object
      org.h2.util.Utils

    public class Utils

extends java.lang.Object

This utility class contains miscellaneous functions.

Field Summary
`static byte[]` `EMPTY_BYTES` An 0-size byte array.
`static int[]` `EMPTY_INT_ARRAY` An 0-size int array.

Method Summary
`static byte[]` `cloneByteArray(byte[] b)` Create a new byte array and copy all the data.
`static int` `compareNotNull(byte[] data1, byte[] data2)` Compare the contents of two byte arrays.
`static boolean` `compareSecure(byte[] test, byte[] good)` Compare two byte arrays.
`static java.lang.String` `convertBytesToString(byte[] value)` Convert a byte array to a hex encoded string.
`static java.lang.String` `convertBytesToString(byte[] value, int len)` Convert a byte array to a hex encoded string.
`static byte[]` `convertStringToBytes(java.lang.String s)` Convert a hex encoded string to a byte array.
`static byte[]` `copy(byte[] source, byte[] target)` Copy the contents of the source array to the target array.
`static java.lang.Object` `deserialize(byte[] data)` De-serialize the byte array to an object.
`static int` `getByteArrayHash(byte[] value)` Calculate the hash code of the given byte array.
`static int` `getMemoryFree()` Get the free memory in KB.
`static long` `getMemoryMax()` Get the maximum memory in KB.
`static int` `getMemoryUsed()` Get the used memory in KB.
`static byte[]` `getResource(java.lang.String name)` Get a resource from the resource map.
`static int` `hashCode(java.lang.Object o)` Calculate the hash code of the given object.
`static int` `indexOf(byte[] bytes, byte[] pattern, int start)` Calculate the index of the first occurrence of the pattern in the byte array, starting with the given index.
`static java.lang.Class<?>` `loadUserClass(java.lang.String className)` Load a class, but check if it is allowed to load this class first.
`static byte[]` `newBytes(int len)` Create an array of bytes with the given size.
`static int[]` `newIntArray(int len)` Create an int array with the given size.
`static long[]` `newLongArray(int len)` Create a long array with the given size.
`static long` `readLong(byte[] buff, int pos)` Read a long value from the byte array at the given position.
`static byte[]` `serialize(java.lang.Object obj)` Serialize the object to a byte array.
`static void` `writeLong(byte[] buff, int pos, long x)` Write a long value to the byte array.

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

Field Detail

### EMPTY_BYTES

    public static final byte[] EMPTY_BYTES

  An 0-size byte array.

### EMPTY_INT_ARRAY

    public static final int[] EMPTY_INT_ARRAY

  An 0-size int array.

Method Detail

### readLong

    public static long readLong(byte[] buff,
                                int pos)

  Read a long value from the byte array at the given position. The most significant byte is read first.

  Parameters:
    `buff` - the byte array
    `pos` - the position
  Returns:
    the value

### writeLong

    public static void writeLong(byte[] buff,
                                 int pos,
                                 long x)

  Write a long value to the byte array.

  Parameters:
    `buff` - the byte array
    `pos` - the position
    `x` - the value

### indexOf

    public static int indexOf(byte[] bytes,
                              byte[] pattern,
                              int start)

  Calculate the index of the first occurrence of the pattern in the byte array, starting with the given index. This methods returns -1 if the pattern has not been found, and the start position if the pattern is empty.

  Parameters:
    `bytes` - the byte array
    `pattern` - the pattern
    `start` - the start index from where to search
  Returns:
    the index

### convertStringToBytes

    public static byte[] convertStringToBytes(java.lang.String s)

  Convert a hex encoded string to a byte array.

  Parameters:
    `s` - the hex encoded string
  Returns:
    the byte array

### getByteArrayHash

    public static int getByteArrayHash(byte[] value)

  Calculate the hash code of the given byte array.

  Parameters:
    `value` - the byte array
  Returns:
    the hash code

### convertBytesToString

    public static java.lang.String convertBytesToString(byte[] value)

  Convert a byte array to a hex encoded string.

  Parameters:
    `value` - the byte array
  Returns:
    the hex encoded string

### convertBytesToString

    public static java.lang.String convertBytesToString(byte[] value,
                                                        int len)

  Convert a byte array to a hex encoded string.

  Parameters:
    `value` - the byte array
    `len` - the number of bytes to encode
  Returns:
    the hex encoded string

### compareSecure

    public static boolean compareSecure(byte[] test,
                                        byte[] good)

  Compare two byte arrays. This method will always loop over all bytes and doesn't use conditional operations in the loop to make sure an attacker can not use a timing attack when trying out passwords.

  Parameters:
    `test` - the first array
    `good` - the second array
  Returns:
    true if both byte arrays contain the same bytes

### compareNotNull

    public static int compareNotNull(byte[] data1,
                                     byte[] data2)

  Compare the contents of two byte arrays. If the content or length of the first array is smaller than the second array, -1 is returned. If the content or length of the second array is smaller than the first array, 1 is returned. If the contents and lengths are the same, 0 is returned.

  Parameters:
    `data1` - the first byte array (must not be null)
    `data2` - the second byte array (must not be null)
  Returns:
    the result of the comparison (-1, 1 or 0)

### copy

    public static byte[] copy(byte[] source,
                              byte[] target)

  Copy the contents of the source array to the target array. If the size if the target array is too small, a larger array is created.

  Parameters:
    `source` - the source array
    `target` - the target array
  Returns:
    the target array or a new one if the target array was too small

### cloneByteArray

    public static byte[] cloneByteArray(byte[] b)

  Create a new byte array and copy all the data. If the size of the byte array is zero, the same array is returned.

  Parameters:
    `b` - the byte array (may not be null)
  Returns:
    a new byte array

### serialize

    public static byte[] serialize(java.lang.Object obj)

  Serialize the object to a byte array.

  Parameters:
    `obj` - the object to serialize
  Returns:
    the byte array

### deserialize

    public static java.lang.Object deserialize(byte[] data)

  De-serialize the byte array to an object.

  Parameters:
    `data` - the byte array
  Returns:
    the object
  Throws:
    `SQLException`

### hashCode

    public static int hashCode(java.lang.Object o)

  Calculate the hash code of the given object. The object may be null.

  Parameters:
    `o` - the object
  Returns:
    the hash code, or 0 if the object is null

### getMemoryUsed

    public static int getMemoryUsed()

  Get the used memory in KB. This method possibly calls System.gc().

  Returns:
    the used memory

### getMemoryFree

    public static int getMemoryFree()

  Get the free memory in KB. This method possibly calls System.gc().

  Returns:
    the free memory

### getMemoryMax

    public static long getMemoryMax()

  Get the maximum memory in KB.

  Returns:
    the maximum memory

### newBytes

    public static byte[] newBytes(int len)

  Create an array of bytes with the given size. If this is not possible because not enough memory is available, an OutOfMemoryError with the requested size in the message is thrown.

  Parameters:
    `len` - the number of bytes requested
  Returns:
    the byte array
  Throws:
    `java.lang.OutOfMemoryError`

### newIntArray

    public static int[] newIntArray(int len)

  Create an int array with the given size.

  Parameters:
    `len` - the number of bytes requested
  Returns:
    the int array

### newLongArray

    public static long[] newLongArray(int len)

  Create a long array with the given size.

  Parameters:
    `len` - the number of bytes requested
  Returns:
    the int array

### loadUserClass

    public static java.lang.Class<?> loadUserClass(java.lang.String className)

  Load a class, but check if it is allowed to load this class first. To perform access rights checking, the system property h2.allowedClasses needs to be set to a list of class file name prefixes.

  Parameters:
    `className` - the name of the class
  Returns:
    the class object

### getResource

    public static byte[] getResource(java.lang.String name)
                              throws java.io.IOException

  Get a resource from the resource map.

  Parameters:
    `name` - the name of the resource
  Returns:
    the resource data
  Throws:
    `java.io.IOException`