ArrayUtil (Neo4j - Community 3.0.7 API)

java.lang.Object
- org.neo4j.helpers.ArrayUtil

public abstract class ArrayUtil
extends Object

Methods "missing" from Arrays are provided here.

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static interface ArrayUtil.ArrayEquality

Nested Classes
Modifier and Type	Class and Description
`static interface`	`ArrayUtil.ArrayEquality`

Field Summary

Fields
Modifier and Type Field and Description

static ArrayUtil.ArrayEquality BOXING_AWARE_ARRAY_EQUALITY

static ArrayUtil.ArrayEquality DEFAULT_ARRAY_EQUALITY

Fields
Modifier and Type	Field and Description
`static ArrayUtil.ArrayEquality`	`BOXING_AWARE_ARRAY_EQUALITY`
`static ArrayUtil.ArrayEquality`	`DEFAULT_ARRAY_EQUALITY`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static boolean`	`approximatelyEqual(double[] that, double[] other, double tolerance)`
`static <T> T[]`	`array(T... varargs)` Returns the array version of the vararg argument.
`static Object`	`clone(Object array)`
`static <T> T[]`	`concat(T[] initial, T... additional)` Create a array from a existing array and additional items following it.
`static <T> T[]`	`concat(T first, T... additional)` Create an array from a single first item and additional items following it.
`static <T> boolean`	`contains(T[] array, int arrayLength, T contains)` Check if array contains item.
`static <T> boolean`	`contains(T[] array, T contains)` Check if array contains item.
`static <T> boolean`	`containsAll(T[] array, T[] contains)` Count items from a different array contained in an array.
`static boolean`	`equals(Object firstArray, Object otherArray)`
`static boolean`	`equals(Object firstArray, Object otherArray, ArrayUtil.ArrayEquality equality)` Check if two arrays are equal.
`static int`	`hashCode(Object array)`
`static <T> int`	`indexOf(T[] array, T item)`
`static boolean`	`isEmpty(Object[] array)` Check if provided array is empty
`static <T> String`	`join(T[] items, String delimiter)` Convert an array to a String using a custom delimiter.
`static <FROM,TO> TO[]`	`map(FROM[] from, Function<FROM,TO> transformer, Class<TO> toClass)` Create new array with all items converted into a new type using a supplied transformer.
`static <T> int`	`missing(T[] array, T[] contains)` Count missing items in an array.
`static <T> boolean`	`nullSafeEquals(T first, T other)` Compare two items for equality; if both are `null` they are regarded as equal.
`static <T> T[]`	`union(T[] first, T[] other)` Get the union of two arrays.
`static <T> T[]`	`without(T[] source, T... toRemove)`

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

- Field Detail
  - DEFAULT_ARRAY_EQUALITY
```
public static final ArrayUtil.ArrayEquality DEFAULT_ARRAY_EQUALITY
```
  - BOXING_AWARE_ARRAY_EQUALITY
```
public static final ArrayUtil.ArrayEquality BOXING_AWARE_ARRAY_EQUALITY
```
- Method Detail
  - hashCode
```
public static int hashCode(Object array)
```
  - equals
```
public static boolean equals(Object firstArray,
                             Object otherArray)
```
  - equals
```
public static boolean equals(Object firstArray,
                             Object otherArray,
                             ArrayUtil.ArrayEquality equality)
```
    Check if two arrays are equal. I also can't believe this method is missing from Arrays. Both arguments must be arrays of some type.
    
    Parameters:
    
    firstArray - value to compare to the other value
    
    otherArray - value to compare to the first value
    
    equality - equality logic
    
    Returns:
    
    Returns true if the arrays are equal
    
    See Also:
    
    for similar functionality.
  - clone
```
public static Object clone(Object array)
```
  - approximatelyEqual
```
public static boolean approximatelyEqual(double[] that,
                                         double[] other,
                                         double tolerance)
```
  - missing
```
public static <T> int missing(T[] array,
                              T[] contains)
```
    Count missing items in an array. The order of items doesn't matter.
    
    Type Parameters:
    
    T - The type of the array items
    
    Parameters:
    
    array - Array to examine
    
    contains - Items to look for
    
    Returns:
    
    how many of the items in contains are missing from array.
  - containsAll
```
public static <T> boolean containsAll(T[] array,
                                      T[] contains)
```
    Count items from a different array contained in an array. The order of items doesn't matter.
    
    Type Parameters:
    
    T - The type of the array items
    
    Parameters:
    
    array - Array to examine
    
    contains - Items to look for
    
    Returns:
    
    true if all items in contains exists in array, otherwise false.
  - contains
```
public static <T> boolean contains(T[] array,
                                   T contains)
```
    Check if array contains item.
    
    Type Parameters:
    
    T - The type of the array items
    
    Parameters:
    
    array - Array to examine
    
    contains - Single item to look for
    
    Returns:
    
    true if contains exists in array, otherwise false.
  - contains
```
public static <T> boolean contains(T[] array,
                                   int arrayLength,
                                   T contains)
```
    Check if array contains item.
    
    Type Parameters:
    
    T - The type of the array items
    
    Parameters:
    
    array - Array to examine
    
    arrayLength - Number of items to check, from the start of the array
    
    contains - Single item to look for
    
    Returns:
    
    true if contains exists in array, otherwise false.
  - nullSafeEquals
```
public static <T> boolean nullSafeEquals(T first,
                                         T other)
```
    Compare two items for equality; if both are null they are regarded as equal.
    
    Type Parameters:
    
    T - The type of the items
    
    Parameters:
    
    first - First item to compare
    
    other - Other item to compare
    
    Returns:
    
    true if first and other are both null or are both equal.
  - union
```
public static <T> T[] union(T[] first,
                            T[] other)
```
    Get the union of two arrays. The resulting array will not contain any duplicates.
    
    Type Parameters:
    
    T - The type of the arrays
    
    Parameters:
    
    first - First array
    
    other - Other array
    
    Returns:
    
    an array containing the union of first and other. Items occurring in both first and other will only have of the two in the resulting union.
  - isEmpty
```
public static boolean isEmpty(Object[] array)
```
    Check if provided array is empty
    
    Parameters:
    
    array - - array to check
    
    Returns:
    
    true if array is null or empty
  - join
```
public static <T> String join(T[] items,
                              String delimiter)
```
    Convert an array to a String using a custom delimiter.
    
    Type Parameters:
    
    T - The type of the array
    
    Parameters:
    
    items - The array to convert
    
    delimiter - The delimiter to use
    
    Returns:
    
    a String representation of items with a custom delimiter in between.
  - map
```
public static <FROM,TO> TO[] map(FROM[] from,
                                 Function<FROM,TO> transformer,
                                 Class<TO> toClass)
```
    Create new array with all items converted into a new type using a supplied transformer.
    
    Type Parameters:
    
    FROM - type of original items
    
    TO - type of the converted items
    
    Parameters:
    
    from - original array
    
    transformer - transformer that converts an item from the original to the target type
    
    toClass - target type for items
    
    Returns:
    
    a new array with all items from from converted into type toClass.
  - concat
```
public static <T> T[] concat(T first,
                             T... additional)
```
    Create an array from a single first item and additional items following it.
    
    Type Parameters:
    
    T - the type of the items
    
    Parameters:
    
    first - the item to put first
    
    additional - the additional items to add to the array
    
    Returns:
    
    a concatenated array where first as the item at index 0 and the additional items following it.
  - concat
```
public static <T> T[] concat(T[] initial,
                             T... additional)
```
    Create a array from a existing array and additional items following it.
    
    Type Parameters:
    
    T - the type of the array items
    
    Parameters:
    
    initial - the initial array
    
    additional - the additional items that would be added into the initial array
    
    Returns:
    
    a concatenated array and the additional items following it.
  - array
```
@SafeVarargs
public static <T> T[] array(T... varargs)
```
    Returns the array version of the vararg argument.
    
    Type Parameters:
    
    T - the type of the items
    
    Parameters:
    
    varargs - the items
    
    Returns:
    
    the array version of the vararg argument.
  - indexOf
```
public static <T> int indexOf(T[] array,
                              T item)
```
  - without
```
public static <T> T[] without(T[] source,
                              T... toRemove)
```

Class ArrayUtil

Nested Class Summary

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

DEFAULT_ARRAY_EQUALITY

BOXING_AWARE_ARRAY_EQUALITY

Method Detail

hashCode

equals

equals

clone

approximatelyEqual

missing

containsAll

contains

contains

nullSafeEquals

union

isEmpty

join

map

concat

concat

array

indexOf

without