ERXArrayUtilities (Project Wonder Reference Documentation)

java.lang.Object
- er.extensions.foundation.ERXArrayUtilities

public class ERXArrayUtilities
extends Object

Collection of NSArray utilities.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`ERXArrayUtilities.AvgNonNullOperator` Define an `NSArray.Operator` for the key avgNonNull.
`static class`	`ERXArrayUtilities.FetchSpecOperator` Define an `NSArray.Operator` for the key fetchSpec.
`static class`	`ERXArrayUtilities.FlattenOperator` Define an `NSArray.Operator` for the key flatten.
`static class`	`ERXArrayUtilities.IsEmptyOperator` Define an `NSArray.Operator` for the key isEmpty.
`static class`	`ERXArrayUtilities.LimitOperator` Define an `NSArray.Operator` for the key limit, which is similar to subarrayWithRange except it is always from 0 to the limit value.
`static class`	`ERXArrayUtilities.MedianOperator` Define an `NSArray.Operator` for the key median.
`static class`	`ERXArrayUtilities.ObjectAtIndexOperator` Define an `NSArray.Operator` for the key objectAtIndex.
`static class`	`ERXArrayUtilities.RemoveNullValuesOperator` Define an `NSArray.Operator` for the key removeNullValues.
`static class`	`ERXArrayUtilities.ReverseOperator` Define an `NSArray.Operator` for the key reverse.
`static class`	`ERXArrayUtilities.SortOperator` Define an `NSArray.Operator` for the key sort.
`static class`	`ERXArrayUtilities.StandardDeviationOperator` Define an `NSArray.Operator` for the key stdDev and popStdDev.
`static class`	`ERXArrayUtilities.SubarrayWithRangeOperator` Define an `NSArray.Operator` for the key subarrayWithRange.
`static class`	`ERXArrayUtilities.UniqueOperator` Define an `NSArray.Operator` for the key unique.

Field Summary

Fields
Modifier and Type	Field and Description
`static String`	`NULL_GROUPING_KEY` Holds the null grouping key for use when grouping objects based on a key that might return null and nulls are allowed

Constructor Summary

Constructors
Constructor and Description

ERXArrayUtilities()

Constructors
Constructor and Description
`ERXArrayUtilities()`

Method Summary

All Methods Static Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`static <T> void`	`addObjectsFromArrayWithoutDuplicates(NSMutableArray<T> array1, Collection<? extends T> array2)` Adds all of the non-duplicate elements from the second array to the mutable array.
`static <T> NSArray<T>`	`arrayByAddingObjectsFromArrayWithoutDuplicates(Collection<? extends T> array1, Collection<? extends T> array2)` Creates an array preserving order by adding all of the non-duplicate values from the second array to the first.
`static <T> NSArray<T>`	`arrayByRemovingFirstObject(NSArray<T> array)` Creates an array that has all of the objects of the parameter array without the first object.
`static <T> NSArray<T>`	`arrayBySelectingInstancesOfClass(Collection<?> array, Class<T> aClass)` Prunes an array for only instances of the given class.
`static <T> boolean`	`arrayContainsAnyObjectFromArray(Collection<? extends T> array1, Collection<? extends T> array2)` Function to determine if an array contains any of the elements of another array.
`static <T> boolean`	`arrayContainsArray(Collection<? extends T> array1, Collection<? extends T> array2)` Function to determine if an array contains all of the elements of another array.
`static NSArray<?>`	`arrayForKeysPath(NSArray<?> array, NSArray<String> keys)` Returns an array of dictionaries containing the key/value pairs for the given paths.
`static NSArray`	`arrayFromPropertyList(String name, NSBundle bundle)` Creates an NSArray from a resource associated with a given bundle that is in property list format.
`static <T,K,V> NSDictionary<K,NSArray<V>>`	`arrayGroupedByKeyPath(Collection<T> objects, ERXKey<K> keyPath, boolean includeNulls, ERXKey<V> valueKeyPath)` Starting with an array of KeyValueCoding-compliant objects and a keyPath, this method calls valueForKey on each object in the array and groups the contents of the array, using the result of the valueForKey call as a key in a dictionary.
`static <T,K,V> NSDictionary<K,NSArray<V>>`	`arrayGroupedByKeyPath(Collection<T> objects, ERXKey<K> keyPath, K nullGroupingKey, ERXKey<V> valueKeyPath)` Starting with an array of KeyValueCoding-compliant objects and a keyPath, this method calls valueForKey on each object in the array and groups the contents of the array, using the result of the valueForKey call as a key in a dictionary.
`static <T,K,V> NSDictionary<K,NSArray<V>>`	`arrayGroupedByKeyPath(Collection<T> objects, String keyPath, boolean includeNulls, String valueKeyPath)` Starting with an array of KeyValueCoding-compliant objects and a keyPath, this method calls valueForKey on each object in the array and groups the contents of the array, using the result of the valueForKey call as a key in a dictionary.
`static <T> NSDictionary`	`arrayGroupedByKeyPath(Collection<T> objects, String keyPath, Object nullGroupingKey, String valueKeyPath)` Starting with an array of KeyValueCoding-compliant objects and a keyPath, this method calls valueForKey on each object in the array and groups the contents of the array, using the result of the valueForKey call as a key in a dictionary.
`static <K,V> NSDictionary<K,NSArray<V>>`	`arrayGroupedByKeyPath(Collection<V> objects, ERXKey<K> keyPath)` Starting with an array of KeyValueCoding-compliant objects and a keyPath, this method calls valueForKey on each object in the array and groups the contents of the array, using the result of the valueForKey call as a key in a dictionary.
`static <K,V> NSDictionary<K,NSArray<V>>`	`arrayGroupedByKeyPath(Collection<V> objects, String keyPath)` Starting with an array of KeyValueCoding-compliant objects and a keyPath, this method calls valueForKey on each object in the array and groups the contents of the array, using the result of the valueForKey call as a key in a dictionary.
`static <T,K,V> NSDictionary<K,NSArray<V>>`	`arrayGroupedByToManyKeyPath(Collection<T> objects, ERXKey<K> keyPath, K nullGroupingKey, ERXKey<V> valueKeyPath)` Typesafe variant of arrayGroupedByToManyKeyPath.
`static <T> NSDictionary`	`arrayGroupedByToManyKeyPath(Collection<T> objects, String keyPath, Object nullGroupingKey, String valueKeyPath)` Groups an array of objects by a given to-many key path, where every single item in the to-many will put the object in the corresponding group.
`static <K,V> NSDictionary<K,NSArray<V>>`	`arrayGroupedByToManyKeyPath(Collection<V> objects, ERXKey<K> keyPath, boolean includeNulls)` Typesafe variant of arrayGroupedByToManyKeyPath.
`static <K,V> NSDictionary<K,NSArray<V>>`	`arrayGroupedByToManyKeyPath(Collection<V> objects, ERXKey<K> keyPath, K nullGroupingKey)` Typesafe variant of arrayGroupedByToManyKeyPath.
`static <K,V> NSDictionary<K,NSArray<V>>`	`arrayGroupedByToManyKeyPath(Collection<V> objects, String keyPath, boolean includeNulls)` Groups an array of objects by a given to-many key path, where every single item in the to-many will put the object in the corresponding group.
`static <K,V> NSDictionary<K,NSArray<V>>`	`arrayGroupedByToManyKeyPath(Collection<V> objects, String keyPath, K nullGroupingKey)` Groups an array of objects by a given to-many key path, where every single item in the to-many will put the object in the corresponding group.
`static boolean`	`arrayIsNullOrEmpty(Collection<?> array)` Check if an array is null or empty.
`static <T> NSArray<T>`	`arrayMinusArray(Collection<T> array, Collection<?> minus)` Subtracts the contents of one array from another.
`static <T> NSArray<T>`	`arrayMinusObject(Collection<T> array, T object)` Subtracts a single object from an array.
`static <T> boolean`	`arraysAreIdenticalSets(Collection<? super T> array1, Collection<? super T> array2)` Simple comparison method to see if two array objects are identical sets.
`static String`	`arrayToLogstring(Collection<String> array)` To create oneLine Log for an NSArray<String> NSArray 配列をログとして出力する時に複数行に渡らないで、一行で収まるように
`static <T> NSArray<T>`	`arrayWithObjectsAtIndexesSwapped(NSArray<T> array, int indexOfObject1, int indexOfObject2)` Deprecated. use `swapObjects(NSArray, int, int)` instead
`static <T> NSArray<T>`	`arrayWithObjectsSwapped(NSArray<T> array, Object object1, Object object2)` Deprecated. use `swapObjects(NSArray, Object, Object)` instead
`static <T> NSArray<T>`	`arrayWithoutDuplicateKeyValue(Iterable<T> objects, ERXKey<?> keyPath)` Filters out duplicates of an array of objects based on the value of the given key path off of those objects.
`static <T> NSArray<T>`	`arrayWithoutDuplicateKeyValue(Iterable<T> objects, String keyPath)` Filters out duplicates of an array of objects based on the value of the given key path off of those objects.
`static <T> NSArray<T>`	`arrayWithoutDuplicates(Collection<T> array)` Filters out all of the duplicate objects in a given array.
`static <T> NSArray<NSArray<T>>`	`batchedArrayWithSize(NSArray<T> array, int batchSize)` Batches an NSArray into sub-arrays of the given size.
`static <T> NSArray<T>`	`deepClone(NSArray<T> array, boolean onlyCollections)` Returns a deep clone of the given array.
`static <T> NSSet<T>`	`deepClone(NSSet<T> set, boolean onlyCollections)` Deprecated. user `ERXSetUtilities.deepClone(NSSet, boolean)` instead
`static <K,T> NSDictionary<K,T>`	`dictionaryOfObjectsIndexedByKeyPath(NSArray<T> array, ERXKey<K> keyPath)` Given an array of objects, returns a dictionary mapping the value by performing valueForKeyPath on each object in the array to the object in the array.
`static <K,T> NSDictionary<K,T>`	`dictionaryOfObjectsIndexedByKeyPath(NSArray<T> array, ERXKey<K> keyPath, boolean throwOnCollision)` Given an array of objects, returns a dictionary mapping the value by performing valueForKeyPath on each object in the array to the object in the array.
`static <K,T> NSDictionary<K,T>`	`dictionaryOfObjectsIndexedByKeyPath(NSArray<T> array, String keyPath)` Given an array of objects, returns a dictionary mapping the value by performing valueForKeyPath on each object in the array to the object in the array.
`static <K,T> NSDictionary<K,T>`	`dictionaryOfObjectsIndexedByKeyPath(NSArray<T> array, String keyPath, boolean throwOnCollision)` Given an array of objects, returns a dictionary mapping the value by performing valueForKeyPath on each object in the array to the object in the array.
`static <K,T> NSDictionary<K,T>`	`dictionaryOfObjectsIndexedByKeyPathThrowOnCollision(NSArray<T> array, ERXKey<K> keyPath, boolean throwOnCollision)` Deprecated. use `dictionaryOfObjectsIndexedByKeyPath(NSArray, ERXKey, boolean)` instead
`static <K,T> NSDictionary<K,T>`	`dictionaryOfObjectsIndexedByKeyPathThrowOnCollision(NSArray<T> array, String keyPath, boolean throwOnCollision)` Deprecated. use `dictionaryOfObjectsIndexedByKeyPath(NSArray, String, boolean)` instead
`static <T> NSArray<T>`	`distinct(Collection<T> array)` Shorter name for arrayWithoutDuplicates, which I always forget the name of.
`static boolean`	`enumerationHasMatchWithQualifierEvaluation(Enumeration<?> enumeration, EOQualifierEvaluation qualifier)` Checks if the given enumeration contains at least one match defined by the given object implementing the `EOQualifierEvaluation` interface.
`static <T> NSArray<T>`	`filteredArrayWithEntityFetchSpecification(NSArray<T> array, String entity, String fetchSpec)` Filters a given array with a named fetch specification.
`static <T> NSArray<T>`	`filteredArrayWithEntityFetchSpecification(NSArray<T> array, String entity, String fetchSpec, NSDictionary<String,?> bindings)` Filters a given array with a named fetch specification and bindings.
`static <T> NSArray<T>`	`filteredArrayWithQualifierEvaluation(Enumeration<T> enumeration, EOQualifierEvaluation qualifier)` Deprecated. use `filteredArrayWithQualifierEvaluation(Iterable, EOQualifierEvaluation)` instead
`static <T> NSArray<T>`	`filteredArrayWithQualifierEvaluation(Iterable<T> iterable, EOQualifierEvaluation qualifier)` Filters any kinds of collections that implement `Iterable` interface such as `NSArray` or `NSSet` using the `EOQualifierEvaluation` interface.
`static <T> NSArray<T>`	`filteredArrayWithQualifierEvaluation(Iterator<T> iterator, EOQualifierEvaluation qualifier)` Deprecated. use `filteredArrayWithQualifierEvaluation(Iterable, EOQualifierEvaluation)` instead
`static <T> T`	`firstObject(List<T> array)` Returns the first object of the array.
`static <T> T`	`firstObjectWithValueForKeyPath(List<T> array, Object value, String keyPath)` Finds the first object in the array with a given value for a given key path.
`static <T,V> T`	`firstObjectWithValueForKeyPath(List<T> array, V value, ERXKey<V> keyPath)` Finds the first object in the array with a given value for a given key path.
`static NSArray`	`flatten(NSArray<?> array)` Recursively flattens an array of arrays and individual objects into a single array of elements.
`static NSArray`	`flatten(NSArray<?> array, boolean filterDuplicates)` Recursively flattens an array of arrays and individual objects into a single array of elements.
`static String`	`friendlyDisplayForKeyPath(NSArray<?> list, String attribute, String nullArrayDisplay, String separator, String finalSeparator)` Displays a list of attributes off of objects in a 'friendly' manner.
`static <T> int`	`indexOfFirstObjectWithValueForKeyPath(Collection<T> array, Object value, String keyPath)` Finds the index of the first object in the array with a given value for a given key path.
`static <T,V> int`	`indexOfFirstObjectWithValueForKeyPath(Collection<T> array, V value, ERXKey<V> keyPath)` Finds the index of the first object in the array with a given value for a given key path.
`static <T> int`	`indexOfObjectUsingEqualator(Collection<T> array, T object, ERXEqualator equalator)` Locates an object within an array using a custom equality check provided as an ERXEqualator.
`static void`	`initialize()` Will register new NSArray operators sort, sortAsc, sortDesc, sortInsensitiveAsc, sortInsensitiveDesc, unique, flatten, reverse, limit, and fetchSpec
`static <T> NSArray<T>`	`intersectingElements(Collection<? extends T> array1, Collection<? extends T> array2)` Intersects the elements of two arrays.
`static boolean`	`iteratorHasMatchWithQualifierEvaluation(Iterator<?> iterator, EOQualifierEvaluation qualifier)` Checks if the given iterator contains at least one match defined by the given object implementing the `EOQualifierEvaluation` interface.
`static Number`	`median(NSArray<?> array, String keypath)` Calculates the median value of an array.
`static String[]`	`objectArrayCastToStringArray(Object[] o)` Converts an Object array to a String array by casting each element.
`static String`	`objectArraysToString(NSArray<Object[][]> array)` pretty prints a NSArray of two dimensional Object array which is ugly when using toString
`static String`	`objectArrayToString(Object[] o)` pretty prints an Object array which is ugly when using toString
`static String`	`objectArrayToString(Object[][] array)` pretty prints a two dimensional Object array which is ugly when using toString
`static <T> NSArray<T>`	`objectsWithValueForKeyPath(Collection<T> array, Object value, String keyPath)` Walks over an array and returns an array of objects from that array that have a particular value for a particular key path.
`static <T,V> NSArray<T>`	`objectsWithValueForKeyPath(Collection<T> array, V value, ERXKey<V> keyPath)` Walks over an array and returns an array of objects from that array that have a particular value for a particular key path.
`static <T> NSArray<T>`	`removeNullValues(NSArray<T> array)` Removes all occurrences of NSKeyValueCoding.NullValue in the provided array
`static <T> NSArray<T>`	`removeNullValues(NSArray<T> target, NSArray<T> array)` Removes all occurrences of NSKeyValueCoding.NullValue in the provided array
`static <T> NSArray<T>`	`removeNullValuesFromEnd(NSArray<T> array)` removes all occurrences of NSKeyValueCoding.Null from the end of the array
`static <T> NSArray<T>`	`reverse(List<T> array)` Reverses the elements of an array.
`static <T> void`	`safeAddObject(NSMutableArray<T> array, T object)` Adds the object to the mutable array if the object is not null.
`static <T> NSSet<T>`	`setFromArray(NSArray<T> array)` Deprecated. use `ERXSetUtilities.setFromArray(Collection)` instead
`static <T> void`	`shiftObjectLeft(NSMutableArray<T> array, T object)` Shifts a given object in an array one value to the left (index--).
`static <T> void`	`shiftObjectRight(NSMutableArray<T> array, T object)` Shifts a given object in an array one value to the right (index++).
`static void`	`sortArrayWithKey(NSMutableArray<?> array, String key)` Sorts a given mutable array with a key in place.
`static void`	`sortArrayWithKey(NSMutableArray<?> array, String key, NSSelector selector)` Sorts a given mutable array with a key in place.
`static <T> NSArray<T>`	`sortedArraySortedWithKey(NSArray<T> array, String key)` Sorts a given array with a key in ascending fashion.
`static <T> NSArray<T>`	`sortedArraySortedWithKey(NSArray<T> array, String key, NSSelector selector)` Sorts a given array with a key in ascending fashion.
`static <T> NSArray<T>`	`sortedArraySortedWithKeys(NSArray<T> array, NSArray<String> keys, NSSelector selector)` Sorts a given array with a set of keys according to the given selector.
`static <T> NSArray<T>`	`sortedArrayUsingComparator(NSArray<T> array, NSComparator comparator)` Just like the method `NSArray.sortedArrayUsingComparator(NSComparator)`, except it catches the NSComparator.ComparisonException and, if thrown, it wraps it in a runtime exception.
`static <T> NSMutableArray<T>`	`sortedMutableArraySortedWithKey(NSArray<T> array, String key)` Sorts a given array with a key in ascending fashion and returns a mutable clone of the result.
`static NSSelector`	`sortSelectorWithKey(String key)` The qualifiers EOSortOrdering.CompareAscending and friends are actually 'special' and processed in a different/faster way when sorting than a selector that would be created by: `new NSSelector("compareAscending", ObjectClassArray)` This method eases the pain on creating those selectors from a string.
`static Number`	`stdDev(NSArray<?> array, String keypath, boolean isPopulation)` Finds the standard deviation of the numeric values found in the array at the specified keypath.
`static <T> NSArray<T>`	`swapObjects(NSArray<T> array, int indexA, int indexB)` Swaps two objects at the given indexes in an array and returns a new modified array.
`static <T> NSArray<T>`	`swapObjects(NSArray<T> array, T a, int indexB)` Swaps the object a with the object at the given index in an array and returns a new modified array.
`static <T> NSArray<T>`	`swapObjects(NSArray<T> array, T a, T b)` Swaps the objects in an array and returns a new modified array.
`static <T> void`	`swapObjects(NSMutableArray<T> array, int indexA, int indexB)` Swaps two objects at the given indexes in an array inplace.
`static <T> void`	`swapObjects(NSMutableArray<T> array, T a, int indexB)` Swaps the object a with the object at the given index in an array inplace.
`static <T> void`	`swapObjects(NSMutableArray<T> array, T a, T b)` Swaps the given objects in an array inplace.
`static <T> void`	`swapObjectsAtIndexesInArray(NSMutableArray<T> array, int indexOfA, int indexOfB)` Deprecated. use `swapObjects(NSMutableArray, int, int)` instead
`static <T> void`	`swapObjectsInArray(NSMutableArray<T> array, T a, T b)` Deprecated. use `swapObjects(NSMutableArray, Object, Object)` instead
`static <T> void`	`swapObjectWithObjectAtIndexInArray(NSMutableArray<T> array, T a, int indexOfB)` Deprecated. use `swapObjects(NSMutableArray, Object, int)` instead
`static String[]`	`toStringArray(List<?> array)`
`static NSArray`	`valuesForKeyPaths(Object source, Collection<String> keyPaths)` Performs multiple key-value coding calls against an array or an object.

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

- Field Detail
  - NULL_GROUPING_KEY
```
public static final String NULL_GROUPING_KEY
```
    Holds the null grouping key for use when grouping objects based on a key that might return null and nulls are allowed
    
    See Also:
    
    Constant Field Values
- Constructor Detail
  - ERXArrayUtilities
```
public ERXArrayUtilities()
```
- Method Detail
  - setFromArray
```
@Deprecated
public static <T> NSSet<T> setFromArray(NSArray<T> array)
```
    Deprecated. use ERXSetUtilities.setFromArray(Collection) instead
    
    Simply utility method to create a concrete set object from an array.
    
    Parameters:
    
    array - of elements
    
    Returns:
    
    set created from given array
  - sortSelectorWithKey
```
public static NSSelector sortSelectorWithKey(String key)
```
    The qualifiers EOSortOrdering.CompareAscending and friends are actually 'special' and processed in a different/faster way when sorting than a selector that would be created by: new NSSelector("compareAscending", ObjectClassArray) This method eases the pain on creating those selectors from a string.
    
    Parameters:
    
    key - sort key
    
    Returns:
    
    selector for the given sort ordering key or null
  - arrayGroupedByKeyPath
```
public static <K,V> NSDictionary<K,NSArray<V>> arrayGroupedByKeyPath(Collection<V> objects,
                                                                     ERXKey<K> keyPath)
```
    Starting with an array of KeyValueCoding-compliant objects and a keyPath, this method calls valueForKey on each object in the array and groups the contents of the array, using the result of the valueForKey call as a key in a dictionary. If passed a null array, null is returned. If passed a null keyPath, an empty dictionary is returned. This is a typesafe variant of arrayGroupedByKeyPath(NSArray<V> objects, String keyPath).
    See arrayGroupedByKeyPath(NSArray<V> objects, String keyPath) for examples.
    This method calls arrayGroupedByKeyPath(NSArray objects, String keyPath, Object nullGroupingKey, String valueKeyPath) with includeNulls set to true and valueKeyPath set to null.
    
    Parameters:
    
    objects - array of objects to be grouped
    
    keyPath - path into objects used to group the objects
    
    Returns:
    
    a dictionary where the keys are the grouped values and the objects are arrays of the objects that have that value. Objects for which the key path returns null will be grouped with the key NULL_GROUPING_KEY
  - arrayGroupedByKeyPath
```
public static <K,V> NSDictionary<K,NSArray<V>> arrayGroupedByKeyPath(Collection<V> objects,
                                                                     String keyPath)
```
    Starting with an array of KeyValueCoding-compliant objects and a keyPath, this method calls valueForKey on each object in the array and groups the contents of the array, using the result of the valueForKey call as a key in a dictionary. If passed a null array, null is returned. If passed a null keyPath, an empty dictionary is returned.
    If one starts with:
```
( { lastName = "Barker"; firstName = "Bob"; favoriteColor = "blue"; },
{ firstName = "Bob"; favoriteColor = "red"; },
{ lastName = "Further"; firstName = "Frank"; favoriteColor = "green"; } )
```
    and one calls arrayGroupedByKeyPath(objects, "firstName"), one gets:
```
{ "Bob" = ( { lastName = "Barker"; firstName = "Bob"; favoriteColor = "blue"; }, { firstName = "Bob"; favoriteColor = "red"; } );
"Frank" = ( { lastName = "Further"; firstName = "Frank"; favoriteColor = "green"; } ); }
```
    If one calls arrayGroupedByKeyPath(objects, "lastName"), one gets:
```
{ "Bob" = ( { lastName = "Barker"; firstName = "Bob"; favoriteColor = "blue"; } );
"Frank" = ( { lastName = "Further"; firstName = "Frank"; favoriteColor = "green"; } );
"**** NULL GROUPING KEY ****" = ( { firstName = "Bob"; favoriteColor = "red"; } ); }
```
    This method calls arrayGroupedByKeyPath(objects, keyPath, includeNulls, valueKeyPath) with includeNulls set to true and valueKeyPath set to null.
    Parameters:
    
    objects - array of objects to be grouped
    
    keyPath - path into objects used to group the objects
    
    Returns:
    
    a dictionary where the keys are the grouped values and the objects are arrays of the objects that have that value. Objects for which the key path returns null will be grouped with the key NULL_GROUPING_KEY
  - arrayGroupedByKeyPath
```
public static <T,K,V> NSDictionary<K,NSArray<V>> arrayGroupedByKeyPath(Collection<T> objects,
                                                                       ERXKey<K> keyPath,
                                                                       boolean includeNulls,
                                                                       ERXKey<V> valueKeyPath)
```
    Starting with an array of KeyValueCoding-compliant objects and a keyPath, this method calls valueForKey on each object in the array and groups the contents of the array, using the result of the valueForKey call as a key in a dictionary. If passed a null array, null is returned. If passed a null keyPath, an empty dictionary is returned. If valueKeyPath is not null, then the grouped arrays each have valueForKey called with valueKeyPath and the grouped arrays are replaced with the results of those calls. This is a typesafe variant of arrayGroupedByKeyPath(NSArray<T> objects, String keyPath, boolean includeNulls, String valueKeyPath).
    See arrayGroupedByKeyPath(NSArray<T> objects, String keyPath, boolean includeNulls, String valueKeyPath) for examples.
    
    Parameters:
    
    objects - array of objects to be grouped
    
    keyPath - path into objects used to group the objects
    
    includeNulls - determines if keyPaths that resolve to null are included in the resulting dictionary
    
    valueKeyPath - used to call valueForKey on the arrays in the results dictionary, with the results of those calls each replacing the corresponding array in the results dictionary.
    
    Returns:
    
    a dictionary where the keys are the grouped values and the objects are arrays of the objects that have that value. Objects for which the key path returns null will be grouped with the key NULL_GROUPING_KEY
  - arrayGroupedByKeyPath
```
public static <T,K,V> NSDictionary<K,NSArray<V>> arrayGroupedByKeyPath(Collection<T> objects,
                                                                       String keyPath,
                                                                       boolean includeNulls,
                                                                       String valueKeyPath)
```
    Starting with an array of KeyValueCoding-compliant objects and a keyPath, this method calls valueForKey on each object in the array and groups the contents of the array, using the result of the valueForKey call as a key in a dictionary. If passed a null array, null is returned. If passed a null keyPath, an empty dictionary is returned. If valueKeyPath is not null, then the grouped arrays each have valueForKey called with valueKeyPath and the grouped arrays are replaced with the results of those calls.
    If one starts with:
```
( { lastName = "Barker"; firstName = "Bob"; favoriteColor = "blue"; },
{ firstName = "Bob"; favoriteColor = "red"; },
{ lastName = "Further"; firstName = "Frank"; favoriteColor = "green"; } )
```
    and one calls arrayGroupedByKeyPath(objects, "firstName", true, "favoriteColor"), one gets:
```
{Frank = ("green"); Bob = ("blue", "red");
```
    If one calls arrayGroupedByKeyPath(objects, "lastName", false, "favoriteColor"), one gets:
```
{Further = ("green"); Barker = ("blue"); }
```
    If one calls arrayGroupedByKeyPath(objects, "lastName", true, "favoriteColor"), one gets:
```
{Further = ("green"); Barker = ("blue"); "**** NULL GROUPING KEY ****" = ("red"); }
```
    Parameters:
    
    objects - array of objects to be grouped
    
    keyPath - path into objects used to group the objects
    
    includeNulls - determines if keyPaths that resolve to null are included in the resulting dictionary
    
    valueKeyPath - used to call valueForKey on the arrays in the results dictionary, with the results of those calls each replacing the corresponding array in the results dictionary.
    
    Returns:
    
    a dictionary where the keys are the grouped values and the objects are arrays of the objects that have that value. Objects for which the key path returns null will be grouped with the key NULL_GROUPING_KEY
  - arrayGroupedByKeyPath
```
public static <T,K,V> NSDictionary<K,NSArray<V>> arrayGroupedByKeyPath(Collection<T> objects,
                                                                       ERXKey<K> keyPath,
                                                                       K nullGroupingKey,
                                                                       ERXKey<V> valueKeyPath)
```
    Starting with an array of KeyValueCoding-compliant objects and a keyPath, this method calls valueForKey on each object in the array and groups the contents of the array, using the result of the valueForKey call as a key in a dictionary. If passed a null array, null is returned. If passed a null keyPath, an empty dictionary is returned. If valueKeyPath is not null, then the grouped arrays each have valueForKey called with valueKeyPath and the grouped arrays are replaced with the results of those calls. This is a typesafe variant of arrayGroupedByKeyPath(NSArray objects, String keyPath, Object nullGroupingKey, String valueKeyPath).
    See arrayGroupedByKeyPath(NSArray objects, String keyPath, Object nullGroupingKey, String valueKeyPath) for examples.
    
    Parameters:
    
    objects - array of objects to be grouped
    
    keyPath - path into objects used to group the objects
    
    nullGroupingKey - used as the key in the results dictionary for the array of objects for which the valueForKey with keyPath result is null.
    
    valueKeyPath - used to call valueForKey on the arrays in the results dictionary, with the results of those calls each replacing the corresponding array in the results dictionary.
    
    Returns:
    
    a dictionary where the keys are the grouped values and the objects are arrays of the objects that have that value. Objects for which the key path returns null will be grouped with the key NULL_GROUPING_KEY
  - arrayGroupedByKeyPath
```
public static <T> NSDictionary arrayGroupedByKeyPath(Collection<T> objects,
                                                     String keyPath,
                                                     Object nullGroupingKey,
                                                     String valueKeyPath)
```
    Starting with an array of KeyValueCoding-compliant objects and a keyPath, this method calls valueForKey on each object in the array and groups the contents of the array, using the result of the valueForKey call as a key in a dictionary. If passed a null array, null is returned. If passed a null keyPath, an empty dictionary is returned. If valueKeyPath is not null, then the grouped arrays each have valueForKey called with valueKeyPath and the grouped arrays are replaced with the results of that call.
    If one starts with:
```
( { lastName = "Barker"; firstName = "Bob"; favoriteColor = "blue"; },
{ firstName = "Bob"; favoriteColor = "red"; },
{ lastName = "Further"; firstName = "Frank"; favoriteColor = "green"; } )
```
    and one calls arrayGroupedByKeyPath(objects, "firstName", null, "favoriteColor"), one gets:
```
{Frank = ("green"); Bob = ("blue", "red");
```
    If one calls arrayGroupedByKeyPath(objects, "lastName", "extra", "favoriteColor"), one gets:
```
{Further = ("green"); Barker = ("blue"); "extra" = ("red"); }
```
    If one calls arrayGroupedByKeyPath(objects, "lastName", null, "favoriteColor"), one gets:
```
{Further = ("green"); Barker = ("blue"); "**** NULL GROUPING KEY ****" = ("red"); }
```
    Parameters:
    
    objects - array of objects to be grouped
    
    keyPath - path into objects used to group the objects
    
    nullGroupingKey - used as the key in the results dictionary for the array of objects for which the valueForKey with keyPath result is null.
    
    valueKeyPath - used to call valueForKey on the arrays in the results dictionary, with the results of those calls each replacing the corresponding array in the results dictionary.
    
    Returns:
    
    a dictionary where the keys are the grouped values and the objects are arrays of the objects that have that value. Objects for which the key path returns null will be grouped with the key NULL_GROUPING_KEY
  - arrayGroupedByToManyKeyPath
```
public static <K,V> NSDictionary<K,NSArray<V>> arrayGroupedByToManyKeyPath(Collection<V> objects,
                                                                           ERXKey<K> keyPath,
                                                                           boolean includeNulls)
```
    Typesafe variant of arrayGroupedByToManyKeyPath.
    
    Parameters:
    
    objects - the objects to be grouped
    
    keyPath - the key to group by
    
    includeNulls - determines if the key paths that resolve to null should be allowed in the group
    
    Returns:
    
    the resulting dictionary
  - arrayGroupedByToManyKeyPath
```
public static <K,V> NSDictionary<K,NSArray<V>> arrayGroupedByToManyKeyPath(Collection<V> objects,
                                                                           String keyPath,
                                                                           boolean includeNulls)
```
    Groups an array of objects by a given to-many key path, where every single item in the to-many will put the object in the corresponding group. A typical example is an array of users with a roles relationship. The result to calling arrayGroupedByToManyKeyPath(users, "roles.name") would be "admin" = (user1, user2); "editor" = (user3);.... The dictionary that is returned contains keys that correspond to the grouped keys values. This means that the object pointed to by the key path must be a cloneable object. For instance using the key path 'users' would not work because enterprise objects are not cloneable. Instead you might choose to use the key path 'users.name' of 'users.primaryKey', if your enterprise objects support this see ERXGenericRecord if interested.
    
    Parameters:
    
    objects - array of objects to be grouped
    
    keyPath - path used to group the objects.
    
    includeNulls - determines if keyPaths that resolve to null should be allowed into the group.
    
    Returns:
    
    a dictionary where the keys are the grouped values and the objects are arrays of the objects that have the grouped characteristic. Note that if the key path returns null then one of the keys will be the static ivar NULL_GROUPING_KEY
  - arrayGroupedByToManyKeyPath
```
public static <K,V> NSDictionary<K,NSArray<V>> arrayGroupedByToManyKeyPath(Collection<V> objects,
                                                                           ERXKey<K> keyPath,
                                                                           K nullGroupingKey)
```
    Typesafe variant of arrayGroupedByToManyKeyPath.
    
    Parameters:
    
    objects - array of objects to be grouped
    
    keyPath - path used to group the objects.
    
    nullGroupingKey - if not-null, determines if keyPaths that resolve to null should be allowed into the group; if so, this key is used for them
    
    Returns:
    
    a dictionary where the keys are the grouped values and the objects are arrays of the objects that have the grouped characteristic. Note that if the key path returns null then one of the keys will be the static ivar NULL_GROUPING_KEY
  - arrayGroupedByToManyKeyPath
```
public static <K,V> NSDictionary<K,NSArray<V>> arrayGroupedByToManyKeyPath(Collection<V> objects,
                                                                           String keyPath,
                                                                           K nullGroupingKey)
```
    Groups an array of objects by a given to-many key path, where every single item in the to-many will put the object in the corresponding group. The dictionary that is returned contains keys that correspond to the grouped keys values. This means that the object pointed to by the key path must be a cloneable object. For instance using the key path 'users' would not work because enterprise objects are not cloneable. Instead you might choose to use the key path 'users.name' of 'users.primaryKey', if your enterprise objects support this see ERXGenericRecord if interested.
    
    Parameters:
    
    objects - array of objects to be grouped
    
    keyPath - path used to group the objects.
    
    nullGroupingKey - if not-null, determines if keyPaths that resolve to null should be allowed into the group; if so, this key is used for them
    
    Returns:
    
    a dictionary where the keys are the grouped values and the objects are arrays of the objects that have the grouped characteristic. Note that if the key path returns null then one of the keys will be the static ivar NULL_GROUPING_KEY
  - arrayGroupedByToManyKeyPath
```
public static <T,K,V> NSDictionary<K,NSArray<V>> arrayGroupedByToManyKeyPath(Collection<T> objects,
                                                                             ERXKey<K> keyPath,
                                                                             K nullGroupingKey,
                                                                             ERXKey<V> valueKeyPath)
```
    Typesafe variant of arrayGroupedByToManyKeyPath.
    
    Parameters:
    
    objects - array of objects to be grouped
    
    keyPath - path used to group the objects.
    
    nullGroupingKey - if not-null, determines if keyPaths that resolve to null should be allowed into the group; if so, this key is used for them
    
    valueKeyPath - allows the grouped objects in the result to be derived from objects (by evaluating valueKeyPath), instead of being members of the objects collection. Objects that evaluate valueKeyPath to null have no value included in the result
    
    Returns:
    
    a dictionary where the keys are the grouped values and the objects are arrays of the objects that have the grouped characteristic. Note that if the key path returns null then one of the keys will be the static ivar NULL_GROUPING_KEY
  - arrayGroupedByToManyKeyPath
```
public static <T> NSDictionary arrayGroupedByToManyKeyPath(Collection<T> objects,
                                                           String keyPath,
                                                           Object nullGroupingKey,
                                                           String valueKeyPath)
```
    Groups an array of objects by a given to-many key path, where every single item in the to-many will put the object in the corresponding group. The dictionary that is returned contains keys that correspond to the grouped keys values. This means that the object pointed to by the key path must be a cloneable object. For instance using the key path 'users' would not work because enterprise objects are not cloneable. Instead you might choose to use the key path 'users.name' of 'users.primaryKey', if your enterprise objects support this see ERXGenericRecord if interested.
    
    Parameters:
    
    objects - array of objects to be grouped
    
    keyPath - path used to group the objects.
    
    nullGroupingKey - if not-null, determines if keyPaths that resolve to null should be allowed into the group; if so, this key is used for them
    
    valueKeyPath - allows the grouped objects in the result to be derived from objects (by evaluating valueKeyPath), instead of being members of the objects collection. Objects that evaluate valueKeyPath to null have no value included in the result
    
    Returns:
    
    a dictionary where the keys are the grouped values and the objects are arrays of the objects that have the grouped characteristic. Note that if the key path returns null then one of the keys will be the static ivar NULL_GROUPING_KEY
  - arraysAreIdenticalSets
```
public static <T> boolean arraysAreIdenticalSets(Collection<? super T> array1,
                                                 Collection<? super T> array2)
```
    Simple comparison method to see if two array objects are identical sets.
    
    Parameters:
    
    array1 - first array
    
    array2 - second array
    
    Returns:
    
    result of comparison
  - filteredArrayWithQualifierEvaluation
```
@Deprecated
public static <T> NSArray<T> filteredArrayWithQualifierEvaluation(Enumeration<T> enumeration,
                                                                              EOQualifierEvaluation qualifier)
```
    Deprecated. use filteredArrayWithQualifierEvaluation(Iterable, EOQualifierEvaluation) instead
    
    Filters any kinds of collections that implements Enumeration interface such as NSArray, NSSet, Vector and Hashtable using the EOQualifierEvaluation interface.
    
    Parameters:
    
    enumeration - to be filtered; to obtain an enumeration, use objectEnumerator() for the collections in com.webobjects.foundation package and use elements() for the Vector and Hashtable
    
    qualifier - to do the filtering
    
    Returns:
    
    array of filtered results.
  - filteredArrayWithQualifierEvaluation
```
public static <T> NSArray<T> filteredArrayWithQualifierEvaluation(Iterable<T> iterable,
                                                                  EOQualifierEvaluation qualifier)
```
    Filters any kinds of collections that implement Iterable interface such as NSArray or NSSet using the EOQualifierEvaluation interface.
    
    Type Parameters:
    
    T - class of array items
    
    Parameters:
    
    iterable - to be filtered
    
    qualifier - to do the filtering
    
    Returns:
    
    array of filtered results
  - enumerationHasMatchWithQualifierEvaluation
```
public static boolean enumerationHasMatchWithQualifierEvaluation(Enumeration<?> enumeration,
                                                                 EOQualifierEvaluation qualifier)
```
    Checks if the given enumeration contains at least one match defined by the given object implementing the EOQualifierEvaluation interface.
    
    Parameters:
    
    enumeration - to be tested
    
    qualifier - to do the filtering
    
    Returns:
    
    true if there is at least one match
  - iteratorHasMatchWithQualifierEvaluation
```
public static boolean iteratorHasMatchWithQualifierEvaluation(Iterator<?> iterator,
                                                              EOQualifierEvaluation qualifier)
```
    Checks if the given iterator contains at least one match defined by the given object implementing the EOQualifierEvaluation interface.
    
    Parameters:
    
    iterator - to be tested
    
    qualifier - to do the filtering
    
    Returns:
    
    true if there is at least one match
  - filteredArrayWithQualifierEvaluation
```
@Deprecated
public static <T> NSArray<T> filteredArrayWithQualifierEvaluation(Iterator<T> iterator,
                                                                              EOQualifierEvaluation qualifier)
```
    Deprecated. use filteredArrayWithQualifierEvaluation(Iterable, EOQualifierEvaluation) instead
    
    Filters any kind of collections that implements Iterator interface such as ArrayList, HashMap, SortedSet and TreeSet using the EOQualifierEvaluation interface.
    
    Parameters:
    
    iterator - to be filtered; use iterator() to obtain an iterator from the collections
    
    qualifier - to do the filtering
    
    Returns:
    
    array of filtered results.
  - arrayWithoutDuplicateKeyValue
```
public static <T> NSArray<T> arrayWithoutDuplicateKeyValue(Iterable<T> objects,
                                                           ERXKey<?> keyPath)
```
    Filters out duplicates of an array of objects based on the value of the given key path off of those objects. Objects with a null value will be skipped, too.
    
    Type Parameters:
    
    T - class of array items
    
    Parameters:
    
    objects - array of objects
    
    keyPath - key path to be evaluated off of every object
    
    Returns:
    
    filter array of objects based on the value of a key path
  - arrayWithoutDuplicateKeyValue
```
public static <T> NSArray<T> arrayWithoutDuplicateKeyValue(Iterable<T> objects,
                                                           String keyPath)
```
    Filters out duplicates of an array of objects based on the value of the given key path off of those objects. Objects with a null value will be skipped, too.
    
    Type Parameters:
    
    T - class of array items
    
    Parameters:
    
    objects - array of objects
    
    keyPath - key path to be evaluated off of every object
    
    Returns:
    
    filter array of objects based on the value of a key path
  - arrayMinusArray
```
public static <T> NSArray<T> arrayMinusArray(Collection<T> array,
                                             Collection<?> minus)
```
    Subtracts the contents of one array from another. The order of the array should be preserved.
    
    Type Parameters:
    
    T - class of array items
    
    Parameters:
    
    array - array to have values removed from it
    
    minus - array of values to remove from the main array
    
    Returns:
    
    array after performing subtraction
  - arrayMinusObject
```
public static <T> NSArray<T> arrayMinusObject(Collection<T> array,
                                              T object)
```
    Subtracts a single object from an array.
    
    Type Parameters:
    
    T - class of array items
    
    Parameters:
    
    array - array to have value removed from it
    
    object - to be removed
    
    Returns:
    
    array after performing subtraction
  - arrayByAddingObjectsFromArrayWithoutDuplicates
```
public static <T> NSArray<T> arrayByAddingObjectsFromArrayWithoutDuplicates(Collection<? extends T> array1,
                                                                            Collection<? extends T> array2)
```
    Creates an array preserving order by adding all of the non-duplicate values from the second array to the first.
    
    Type Parameters:
    
    T - class of array items
    
    Parameters:
    
    array1 - first array
    
    array2 - second array
    
    Returns:
    
    array containing all of the elements of the first array and all of the non-duplicate elements of the second array.
  - arrayByRemovingFirstObject
```
public static <T> NSArray<T> arrayByRemovingFirstObject(NSArray<T> array)
```
    Creates an array that has all of the objects of the parameter array without the first object.
    
    Type Parameters:
    
    T - class of array items
    
    Parameters:
    
    array - the array to use to create the result
    
    Returns:
    
    an array containing all objects but the first of the parameter array. if null is passed, null is returned. if the parameter array is empty, an empty array is returned.
  - safeAddObject
```
public static <T> void safeAddObject(NSMutableArray<T> array,
                                     T object)
```
    Adds the object to the mutable array if the object is not null.
    
    Type Parameters:
    
    T - class of array items
    
    Parameters:
    
    array - mutable array where non-null object will be added
    
    object - to be added to array
  - addObjectsFromArrayWithoutDuplicates
```
public static <T> void addObjectsFromArrayWithoutDuplicates(NSMutableArray<T> array1,
                                                            Collection<? extends T> array2)
```
    Adds all of the non-duplicate elements from the second array to the mutable array.
    
    Type Parameters:
    
    T - class of array items
    
    Parameters:
    
    array1 - mutable array where non-duplicate objects are added
    
    array2 - array to be added to a1
  - flatten
```
public static NSArray flatten(NSArray<?> array,
                              boolean filterDuplicates)
```
    Recursively flattens an array of arrays and individual objects into a single array of elements.
    For example:
```
NSArray foos; //Assume exists
 NSArray bars = (NSArray)foos.valueForKey("toBars");
 
```
    In this case if foos contained five elements then the array bars will contain five arrays each corresponding to what aFoo.toBars would return. To have the entire collection of bars in one single array you would call: NSArray allBars = flatten(bars)
    Parameters:
    
    array - array to be flattened
    
    filterDuplicates - determines if the duplicate values should be filtered
    
    Returns:
    
    an array containing all of the elements from all of the arrays contained within the array passed in. (Optionally, with duplicate elements filtered out)
  - flatten
```
public static NSArray flatten(NSArray<?> array)
```
    Recursively flattens an array of arrays and individual objects into a single array of elements.
    For example:
```
NSArray foos; //Assume exists
 NSArray bars = (NSArray)foos.valueForKey("toBars");
 
```
    In this case if foos contained five elements then the array bars will contain five arrays each corresponding to what aFoo.toBars would return. To have the entire collection of bars in one single array you would call: NSArray allBars = flatten(bars)
    Parameters:
    
    array - array to be flattened
    
    Returns:
    
    an array containing all of the elements from all of the arrays contained within the array passed in.
  - arrayFromPropertyList
```
public static NSArray arrayFromPropertyList(String name,
                                            NSBundle bundle)
```
    Creates an NSArray from a resource associated with a given bundle that is in property list format.
    
    Parameters:
    
    name - name of the file or resource.
    
    bundle - NSBundle to which the resource belongs.
    
    Returns:
    
    NSArray deserialized from the property list.
  - valuesForKeyPaths
```
public static NSArray valuesForKeyPaths(Object source,
                                        Collection<String> keyPaths)
```
    Performs multiple key-value coding calls against an array or an object.
    
    Parameters:
    
    source - collection or object to be acted upon.
    
    keyPaths - array of key paths.
    
    Returns:
    
    for collections, returns an array containing an array of values for every key path. For objects, returns an array containing a value for every key path.
  - firstObject
```
public static <T> T firstObject(List<T> array)
```
    Returns the first object of the array. If the array is null or empty, null is returned.
    
    Type Parameters:
    
    T - class of array items
    
    Parameters:
    
    array - the array to search
    
    Returns:
    
    the first object in array. null if array is empty or null.
  - indexOfFirstObjectWithValueForKeyPath
```
public static <T,V> int indexOfFirstObjectWithValueForKeyPath(Collection<T> array,
                                                              V value,
                                                              ERXKey<V> keyPath)
```
    Finds the index of the first object in the array with a given value for a given key path. Assumes that all objects in the array either are NSKeyValueCoding.NullValue or have the given key path.
    
    Type Parameters:
    
    T - class of array items
    
    V - class of value from key path
    
    Parameters:
    
    array - the array to search
    
    value - the value to look for
    
    keyPath - the key path to use to compare to value
    
    Returns:
    
    index of the first object with the qualification. -1 if none matches.
  - indexOfFirstObjectWithValueForKeyPath
```
public static <T> int indexOfFirstObjectWithValueForKeyPath(Collection<T> array,
                                                            Object value,
                                                            String keyPath)
```
    Finds the index of the first object in the array with a given value for a given key path. Assumes that all objects in the array either are NSKeyValueCoding.NullValue or have the given key path.
    
    Type Parameters:
    
    T - class of array items
    
    Parameters:
    
    array - the array to search
    
    value - the value to look for
    
    keyPath - the key path to use to compare to value
    
    Returns:
    
    index of the first object with the qualification. -1 if none matches.
  - firstObjectWithValueForKeyPath
```
public static <T,V> T firstObjectWithValueForKeyPath(List<T> array,
                                                     V value,
                                                     ERXKey<V> keyPath)
```
    Finds the first object in the array with a given value for a given key path.
    
    Type Parameters:
    
    T - class of array items
    
    V - class of value from key path
    
    Parameters:
    
    array - the array to search
    
    value - the value to look for
    
    keyPath - the key path to use to compare to value
    
    Returns:
    
    first object in the array with the qualification. null if none matches.
  - firstObjectWithValueForKeyPath
```
public static <T> T firstObjectWithValueForKeyPath(List<T> array,
                                                   Object value,
                                                   String keyPath)
```
    Finds the first object in the array with a given value for a given key path.
    
    Type Parameters:
    
    T - class of array items
    
    Parameters:
    
    array - the array to search
    
    value - the value to look for
    
    keyPath - the key path to use to compare to value
    
    Returns:
    
    first object in the array with the qualification. null if none matches.
  - objectsWithValueForKeyPath
```
public static <T,V> NSArray<T> objectsWithValueForKeyPath(Collection<T> array,
                                                          V value,
                                                          ERXKey<V> keyPath)
```
    Walks over an array and returns an array of objects from that array that have a particular value for a particular key path. Treats null and NSKeyValueCoding.NullValue equivalently. Any NSKeyValueCoding.NullValue objects in the array are skipped. If array is null or empty, an empty array is returned.
    
    Type Parameters:
    
    T - class of array items
    
    V - class of value from key path
    
    Parameters:
    
    array - array to search
    
    value - value to look for
    
    keyPath - key path to apply on each object on the array to compare against valueToLookFor
    
    Returns:
    
    an array of matching objects
  - objectsWithValueForKeyPath
```
public static <T> NSArray<T> objectsWithValueForKeyPath(Collection<T> array,
                                                        Object value,
                                                        String keyPath)
```
    Walks over an array and returns an array of objects from that array that have a particular value for a particular key path. Treats null and NSKeyValueCoding.NullValue equivalently. Any NSKeyValueCoding.NullValue objects in the array are skipped. If array is null or empty, an empty array is returned.
    
    Type Parameters:
    
    T - class of array items
    
    Parameters:
    
    array - array to search
    
    value - value to look for
    
    keyPath - key path to apply on each object on the array to compare against valueToLookFor
    
    Returns:
    
    an array of matching objects
  - indexOfObjectUsingEqualator
```
public static <T> int indexOfObjectUsingEqualator(Collection<T> array,
                                                  T object,
                                                  ERXEqualator equalator)
```
    Locates an object within an array using a custom equality check provided as an ERXEqualator. This is useful if you have an array of EOs and want to find a particular EO in it without regard to editing contexts.
    
    Type Parameters:
    
    T - class of array items
    
    Parameters:
    
    array - the array to search
    
    object - the object to look for
    
    equalator - the equalator to use for performing the equality check between object and each object in the array
    
    Returns:
    
    index of first occurring object in the array that is defined as equal by the equalator. -1 if no such object is found.
  - sortedMutableArraySortedWithKey
```
public static <T> NSMutableArray<T> sortedMutableArraySortedWithKey(NSArray<T> array,
                                                                    String key)
```
    Sorts a given array with a key in ascending fashion and returns a mutable clone of the result.
    
    Parameters:
    
    array - array to be sorted.
    
    key - sort key.
    
    Returns:
    
    mutable clone of sorted array.
  - sortedArraySortedWithKey
```
public static <T> NSArray<T> sortedArraySortedWithKey(NSArray<T> array,
                                                      String key)
```
    Sorts a given array with a key in ascending fashion.
    
    Parameters:
    
    array - array to be sorted.
    
    key - sort key.
    
    Returns:
    
    sorted array.
  - sortedArraySortedWithKey
```
public static <T> NSArray<T> sortedArraySortedWithKey(NSArray<T> array,
                                                      String key,
                                                      NSSelector selector)
```
    Sorts a given array with a key in ascending fashion.
    
    Parameters:
    
    array - array to be sorted.
    
    key - sort key.
    
    selector - sort order selector to use, if null, then sort will be case insensitive ascending.
    
    Returns:
    
    sorted array.
  - sortedArraySortedWithKeys
```
public static <T> NSArray<T> sortedArraySortedWithKeys(NSArray<T> array,
                                                       NSArray<String> keys,
                                                       NSSelector selector)
```
    Sorts a given array with a set of keys according to the given selector.
    
    Parameters:
    
    array - array to be sorted.
    
    keys - sort keys
    
    selector - sort order selector to use, if null, then sort will be case insensitive ascending. a.addObject(theObject); a.addObject(theObject);
    
    Returns:
    
    sorted array.
  - sortArrayWithKey
```
public static void sortArrayWithKey(NSMutableArray<?> array,
                                    String key)
```
    Sorts a given mutable array with a key in place.
    
    Parameters:
    
    array - array to be sorted.
    
    key - sort key.
  - sortArrayWithKey
```
public static void sortArrayWithKey(NSMutableArray<?> array,
                                    String key,
                                    NSSelector selector)
```
    Sorts a given mutable array with a key in place.
    
    Parameters:
    
    array - array to be sorted.
    
    key - sort key.
    
    selector - sort order selector to use, if null, then sort will be ascending.
  - initialize
```
public static void initialize()
```
    Will register new NSArray operators sort, sortAsc, sortDesc, sortInsensitiveAsc, sortInsensitiveDesc, unique, flatten, reverse, limit, and fetchSpec
  - median
```
public static Number median(NSArray<?> array,
                            String keypath)
```
    Calculates the median value of an array. The median is the value for which half of the elements are above and half the elements are below. As such, an array sort is needed and this might be very costly depending of the size of the array.
    
    Parameters:
    
    array - array of objects
    
    keypath - key path for the median
    
    Returns:
    
    the median value
  - stdDev
```
public static Number stdDev(NSArray<?> array,
                            String keypath,
                            boolean isPopulation)
```
    Finds the standard deviation of the numeric values found in the array at the specified keypath. If the keypath is null or empty, then the array values are used instead. If the array has fewer than two objects, null is returned. If isPopulation is true, the population standard deviation is calculated. If isPopulation is false, the sample standard deviation is calculated. Use a true value for isPopulation if you know the values for an entire population and false if you are dealing with a sample.
    
    Parameters:
    
    array - an array of objects
    
    keypath - a key path to a numeric value on each object
    
    isPopulation -
    
    Returns:
    
    the standard deviation for the numeric values
  - distinct
```
public static <T> NSArray<T> distinct(Collection<T> array)
```
    Shorter name for arrayWithoutDuplicates, which I always forget the name of.
    
    Type Parameters:
    
    T - class of array items
    
    Parameters:
    
    array - the array to return distinct values from
    
    Returns:
    
    an array of distinct elements from the input array
  - arrayWithoutDuplicates
```
public static <T> NSArray<T> arrayWithoutDuplicates(Collection<T> array)
```
    Filters out all of the duplicate objects in a given array. Preserves the order now.
    
    Type Parameters:
    
    T - class of array items
    
    Parameters:
    
    array - to be filtered
    
    Returns:
    
    filtered array
  - batchedArrayWithSize
```
public static <T> NSArray<NSArray<T>> batchedArrayWithSize(NSArray<T> array,
                                                           int batchSize)
```
    Batches an NSArray into sub-arrays of the given size.
    
    Type Parameters:
    
    T - class of array items
    
    Parameters:
    
    array - array to batch
    
    batchSize - number of items in each batch
    
    Returns:
    
    NSArray of NSArrays, each with at most batchSize items
  - filteredArrayWithEntityFetchSpecification
```
public static <T> NSArray<T> filteredArrayWithEntityFetchSpecification(NSArray<T> array,
                                                                       String entity,
                                                                       String fetchSpec,
                                                                       NSDictionary<String,?> bindings)
```
    Filters a given array with a named fetch specification and bindings.
    
    Parameters:
    
    array - array to be filtered.
    
    fetchSpec - name of the EOQualifierEvaluation.
    
    entity - name of the EOEntity to which the fetch specification is associated.
    
    bindings - bindings dictionary for qualifier variable substitution.
    
    Returns:
    
    array filtered and sorted by the named fetch specification.
  - filteredArrayWithEntityFetchSpecification
```
public static <T> NSArray<T> filteredArrayWithEntityFetchSpecification(NSArray<T> array,
                                                                       String entity,
                                                                       String fetchSpec)
```
    Filters a given array with a named fetch specification.
    
    Parameters:
    
    array - array to be filtered.
    
    fetchSpec - name of the EOQualifierEvaluation.
    
    entity - name of the EOEntity to which the fetch specification is associated.
    
    Returns:
    
    array filtered and sorted by the named fetch specification.
  - shiftObjectLeft
```
public static <T> void shiftObjectLeft(NSMutableArray<T> array,
                                       T object)
```
    Shifts a given object in an array one value to the left (index--).
    
    Type Parameters:
    
    T - class of array items
    
    Parameters:
    
    array - array to be modified.
    
    object - the object that should be moved
  - shiftObjectRight
```
public static <T> void shiftObjectRight(NSMutableArray<T> array,
                                        T object)
```
    Shifts a given object in an array one value to the right (index++).
    
    Type Parameters:
    
    T - class of array items
    
    Parameters:
    
    array - array to be modified
    
    object - the object that should be moved
  - arrayContainsAnyObjectFromArray
```
public static <T> boolean arrayContainsAnyObjectFromArray(Collection<? extends T> array1,
                                                          Collection<? extends T> array2)
```
    Function to determine if an array contains any of the elements of another array.
    
    Type Parameters:
    
    T - class of array items
    
    Parameters:
    
    array1 - to test if it contains any of the objects
    
    array2 - array of objects to test if the first array contains any of
    
    Returns:
    
    if the first array contains any elements from the second array
  - arrayContainsArray
```
public static <T> boolean arrayContainsArray(Collection<? extends T> array1,
                                             Collection<? extends T> array2)
```
    Function to determine if an array contains all of the elements of another array.
    
    Type Parameters:
    
    T - class of array items
    
    Parameters:
    
    array1 - to test if it contains all of the objects of another array
    
    array2 - array of objects to test if the first array contains all of
    
    Returns:
    
    if the first array contains all of the elements from the second array
  - intersectingElements
```
public static <T> NSArray<T> intersectingElements(Collection<? extends T> array1,
                                                  Collection<? extends T> array2)
```
    Intersects the elements of two arrays. This has the effect of stripping out duplicates.
    
    Type Parameters:
    
    T - class of array items
    
    Parameters:
    
    array1 - the first array
    
    array2 - the second array
    
    Returns:
    
    the intersecting elements
  - reverse
```
public static <T> NSArray<T> reverse(List<T> array)
```
    Reverses the elements of an array.
    
    Type Parameters:
    
    T - class of array items
    
    Parameters:
    
    array - to be reversed
    
    Returns:
    
    reverse ordered array
  - friendlyDisplayForKeyPath
```
public static String friendlyDisplayForKeyPath(NSArray<?> list,
                                               String attribute,
                                               String nullArrayDisplay,
                                               String separator,
                                               String finalSeparator)
```
    Displays a list of attributes off of objects in a 'friendly' manner.
    For example, given an array containing three user objects and the attribute key "firstName", the result of calling this method would be the string: "Max, Anjo and Patrice".
    
    Parameters:
    
    list - of objects to be displayed in a friendly manner
    
    attribute - key to be called on each object in the list
    
    nullArrayDisplay - string to be returned if the list is null or empty
    
    separator - string to be used for the first items
    
    finalSeparator - used between the last items
    
    Returns:
    
    friendly display string
  - arrayForKeysPath
```
public static NSArray<?> arrayForKeysPath(NSArray<?> array,
                                          NSArray<String> keys)
```
    Returns an array of dictionaries containing the key/value pairs for the given paths.
    
    Parameters:
    
    array - array of objects
    
    keys - array of keys
    
    Returns:
    
    array of dictionaries containing values for the key paths
  - removeNullValues
```
public static <T> NSArray<T> removeNullValues(NSArray<T> array)
```
    Removes all occurrences of NSKeyValueCoding.NullValue in the provided array
    
    Parameters:
    
    array - the array from which the NullValue should be removed
    
    Returns:
    
    a new NSArray with the same order than the original array but without NSKeyValueCoding.NullValue objects
  - removeNullValues
```
public static <T> NSArray<T> removeNullValues(NSArray<T> target,
                                              NSArray<T> array)
```
    Removes all occurrences of NSKeyValueCoding.NullValue in the provided array
    
    Parameters:
    
    target - array to remove objects from
    
    array - array of values
    
    Returns:
    
    a new NSArray with the same order than the original array but without NSKeyValueCoding.NullValue objects
  - objectArrayCastToStringArray
```
public static String[] objectArrayCastToStringArray(Object[] o)
```
    Converts an Object array to a String array by casting each element. This is analogous to String[] myStringArray = (String[])myObjectArray; except that it creates a clone of the array.
    
    Parameters:
    
    o - an Object array containing String elements
    
    Returns:
    
    a String array containing the same elements
  - objectArrayToString
```
public static String objectArrayToString(Object[] o)
```
    pretty prints an Object array which is ugly when using toString
    
    Parameters:
    
    o - the object which one wants to print as a String
    
    Returns:
    
    the String which can be used in lets say log.info("my array = "+ERXArrayUtilities.objectArrayToString(myArray));
  - objectArrayToString
```
public static String objectArrayToString(Object[][] array)
```
    pretty prints a two dimensional Object array which is ugly when using toString
    
    Parameters:
    
    array - the object which one wants to print as a String
    
    Returns:
    
    the String which can be used in lets say log.info("my array = "+ERXArrayUtilities.objectArrayToString(myArray));
  - objectArraysToString
```
public static String objectArraysToString(NSArray<Object[][]> array)
```
    pretty prints a NSArray of two dimensional Object array which is ugly when using toString
    
    Parameters:
    
    array - the object which one wants to print as a String
    
    Returns:
    
    the String which can be used in lets say log.info("my array = "+ERXArrayUtilities.objectArrayToString(myArray));
  - removeNullValuesFromEnd
```
public static <T> NSArray<T> removeNullValuesFromEnd(NSArray<T> array)
```
    removes all occurrences of NSKeyValueCoding.Null from the end of the array
    
    Parameters:
    
    array - the array from which the values should be removed
    
    Returns:
    
    a new NSArray which does not have NSKeyValueCoding.Null instances at the end
  - toStringArray
```
public static String[] toStringArray(List<?> array)
```
  - dictionaryOfObjectsIndexedByKeyPath
```
public static <K,T> NSDictionary<K,T> dictionaryOfObjectsIndexedByKeyPath(NSArray<T> array,
                                                                          ERXKey<K> keyPath)
```
    Given an array of objects, returns a dictionary mapping the value by performing valueForKeyPath on each object in the array to the object in the array. This method assume that the value returned for the keyPath attribute will be unique for all the objects in the array. In case of duplicate entry, the new object will replace the previous one in the dictionary.
    This is a typesafe variant of dictionaryOfObjectsIndexedByKeyPath(NSArray<V> objects, String keyPath).
    Calls dictionaryOfObjectsIndexedByKeyPathThrowOnCollision() passing false for throwOnCollision.
    
    Type Parameters:
    
    K - class of key path value
    
    T - class of array items
    
    Parameters:
    
    array - array to index
    
    keyPath - keyPath to index. If any object returns null or NSKeyValueCoding.NullValue for this keyPath, the object is not put into the resulting dictionary.
    
    Returns:
    
    a dictionary indexing the given array. If array is null, an empty dictionary is returned.
  - dictionaryOfObjectsIndexedByKeyPath
```
public static <K,T> NSDictionary<K,T> dictionaryOfObjectsIndexedByKeyPath(NSArray<T> array,
                                                                          String keyPath)
```
    Given an array of objects, returns a dictionary mapping the value by performing valueForKeyPath on each object in the array to the object in the array. This method assume that the value returned for the keyPath attribute will be unique for all the objects in the array. In case of duplicate entry, the new object will replace the previous one in the dictionary.
    Calls dictionaryOfObjectsIndexedByKeyPathThrowOnCollision() passing false for throwOnCollision.
    
    Type Parameters:
    
    K - class of key path value
    
    T - class of array items
    
    Parameters:
    
    array - array to index
    
    keyPath - keyPath to index. If any object returns null or NSKeyValueCoding.NullValue for this keyPath, the object is not put into the resulting dictionary.
    
    Returns:
    
    a dictionary indexing the given array. If array is null, an empty dictionary is returned.
  - dictionaryOfObjectsIndexedByKeyPathThrowOnCollision
```
@Deprecated
public static <K,T> NSDictionary<K,T> dictionaryOfObjectsIndexedByKeyPathThrowOnCollision(NSArray<T> array,
                                                                                                      ERXKey<K> keyPath,
                                                                                                      boolean throwOnCollision)
```
    Deprecated. use dictionaryOfObjectsIndexedByKeyPath(NSArray, ERXKey, boolean) instead
    
    Given an array of objects, returns a dictionary mapping the value by performing valueForKeyPath on each object in the array to the object in the array. This method assume that the value returned for the keyPath attribute will be unique for all the objects in the array. In case of duplicate entry, if throwOnCollision is true, an exception is thrown, otherwise, the the new object will replace the previous one in the dictionary.
    This is a typesafe variant of dictionaryOfObjectsIndexedByKeyPath(NSArray<V> objects, String keyPath, boolean throwOnCollision).
    
    Parameters:
    
    array - array to index
    
    keyPath - keyPath to index. If any object returns null or NSKeyValueCoding.NullValue for this keyPath, the object is not put into the resulting dictionary.
    
    throwOnCollision - if true and two objects in the array have the same non-null (or non-NullValue) value for keyPath, an exception is thrown. If false, the last object in the array wins.
    
    Returns:
    
    a dictionary indexing the given array. If array is null, an empty dictionary is returned.
  - dictionaryOfObjectsIndexedByKeyPathThrowOnCollision
```
@Deprecated
public static <K,T> NSDictionary<K,T> dictionaryOfObjectsIndexedByKeyPathThrowOnCollision(NSArray<T> array,
                                                                                                      String keyPath,
                                                                                                      boolean throwOnCollision)
```
    Deprecated. use dictionaryOfObjectsIndexedByKeyPath(NSArray, String, boolean) instead
    
    Given an array of objects, returns a dictionary mapping the value by performing valueForKeyPath on each object in the array to the object in the array. This method assume that the value returned for the keyPath attribute will be unique for all the objects in the array. In case of duplicate entry, if throwOnCollision is true, an exception is thrown, otherwise, the the new object will replace the previous one in the dictionary.
    
    Parameters:
    
    array - array to index
    
    keyPath - keyPath to index. If any object returns null or NSKeyValueCoding.NullValue for this keyPath, the object is not put into the resulting dictionary.
    
    throwOnCollision - if true and two objects in the array have the same non-null (or non-NullValue) value for keyPath, an exception is thrown. If false, the last object in the array wins.
    
    Returns:
    
    a dictionary indexing the given array. If array is null, an empty dictionary is returned.
  - dictionaryOfObjectsIndexedByKeyPath
```
public static <K,T> NSDictionary<K,T> dictionaryOfObjectsIndexedByKeyPath(NSArray<T> array,
                                                                          ERXKey<K> keyPath,
                                                                          boolean throwOnCollision)
```
    Given an array of objects, returns a dictionary mapping the value by performing valueForKeyPath on each object in the array to the object in the array. This method assume that the value returned for the keyPath attribute will be unique for all the objects in the array. In case of duplicate entry, if throwOnCollision is true, an exception is thrown, otherwise, the the new object will replace the previous one in the dictionary.
    This is a typesafe variant of dictionaryOfObjectsIndexedByKeyPath(NSArray<V> objects, String keyPath, boolean throwOnCollision).
    
    Type Parameters:
    
    K - class of key path value
    
    T - class of array items
    
    Parameters:
    
    array - array to index
    
    keyPath - keyPath to index. If any object returns null or NSKeyValueCoding.NullValue for this keyPath, the object is not put into the resulting dictionary.
    
    throwOnCollision - if true and two objects in the array have the same non-null (or non-NullValue) value for keyPath, an exception is thrown. If false, the last object in the array wins.
    
    Returns:
    
    a dictionary indexing the given array. If array is null, an empty dictionary is returned.
  - dictionaryOfObjectsIndexedByKeyPath
```
public static <K,T> NSDictionary<K,T> dictionaryOfObjectsIndexedByKeyPath(NSArray<T> array,
                                                                          String keyPath,
                                                                          boolean throwOnCollision)
```
    Given an array of objects, returns a dictionary mapping the value by performing valueForKeyPath on each object in the array to the object in the array. This method assume that the value returned for the keyPath attribute will be unique for all the objects in the array. In case of duplicate entry, if throwOnCollision is true, an exception is thrown, otherwise, the the new object will replace the previous one in the dictionary.
    
    Type Parameters:
    
    K - class of key path value
    
    T - class of array items
    
    Parameters:
    
    array - array to index
    
    keyPath - keyPath to index. If any object returns null or NSKeyValueCoding.NullValue for this keyPath, the object is not put into the resulting dictionary.
    
    throwOnCollision - if true and two objects in the array have the same non-null (or non-NullValue) value for keyPath, an exception is thrown. If false, the last object in the array wins.
    
    Returns:
    
    a dictionary indexing the given array. If array is null, an empty dictionary is returned.
  - arrayBySelectingInstancesOfClass
```
public static <T> NSArray<T> arrayBySelectingInstancesOfClass(Collection<?> array,
                                                              Class<T> aClass)
```
    Prunes an array for only instances of the given class.
    
    Type Parameters:
    
    T - class to extract
    
    Parameters:
    
    array - array to process
    
    aClass - class to use. null results in the result being a copy of the array.
    
    Returns:
    
    an array which is a subset of the array where each object in the result is an instance of aClass.
  - sortedArrayUsingComparator
```
public static <T> NSArray<T> sortedArrayUsingComparator(NSArray<T> array,
                                                        NSComparator comparator)
```
    Just like the method NSArray.sortedArrayUsingComparator(NSComparator), except it catches the NSComparator.ComparisonException and, if thrown, it wraps it in a runtime exception. Returns null when passed null for array.
    
    Type Parameters:
    
    T - class of array items
    
    Parameters:
    
    array - the array to sort
    
    comparator - the comparator
    
    Returns:
    
    the sorted array
  - arrayWithObjectsSwapped
```
@Deprecated
public static <T> NSArray<T> arrayWithObjectsSwapped(NSArray<T> array,
                                                                 Object object1,
                                                                 Object object2)
```
    Deprecated. use swapObjects(NSArray, Object, Object) instead
    
    Swaps the two given Objects in the given NSArray and returns a new NSArray. If one of the Objects is not element of the NSArray a RuntimeException will be thrown.
    
    Type Parameters:
    
    T -
    
    Parameters:
    
    array - in that the two given Objects have to be swapped
    
    object1 - one object in the NSArray that will be swapped
    
    object2 - the other object in the NSArray that will be swapped
    
    Returns:
    
    the new NSArray with the swapped elements
    
    Throws:
    
    RuntimeException - if one of the Objects is not in the NSArray
    
    Author:
    
    edgar - Jan 7, 2008
  - arrayWithObjectsAtIndexesSwapped
```
@Deprecated
public static <T> NSArray<T> arrayWithObjectsAtIndexesSwapped(NSArray<T> array,
                                                                          int indexOfObject1,
                                                                          int indexOfObject2)
```
    Deprecated. use swapObjects(NSArray, int, int) instead
    
    Swaps the two objects at the given indexes in the given NSArray and returns a new NSArray.
    
    Parameters:
    
    array - in that the two Objects at the given indexes have to be swapped
    
    indexOfObject1 - index of one object in the NSArray that will be swapped
    
    indexOfObject2 - index of the other object in the NSArray that will be swapped
    
    Returns:
    
    the new NSArray with the swapped elements
    
    Throws:
    
    RuntimeException - if one of the indexes is out of bound
    
    Author:
    
    edgar - Jan 7, 2008
  - swapObjectsInArray
```
@Deprecated
public static <T> void swapObjectsInArray(NSMutableArray<T> array,
                                                      T a,
                                                      T b)
```
    Deprecated. use swapObjects(NSMutableArray, Object, Object) instead
    
    Swaps two objects a and b in an array inplace
    
    Parameters:
    
    array - the array
    
    a - - first object
    
    b - - second object
    
    Throws:
    
    RuntimeException - if one or both indexes are out of bounds
    
    Author:
    
    cug - Jan 7, 2008
  - swapObjectsAtIndexesInArray
```
@Deprecated
public static <T> void swapObjectsAtIndexesInArray(NSMutableArray<T> array,
                                                               int indexOfA,
                                                               int indexOfB)
```
    Deprecated. use swapObjects(NSMutableArray, int, int) instead
    
    Swaps two objects at the given indexes in an array inplace
    
    Parameters:
    
    array - the array
    
    indexOfA - - index of the first object
    
    indexOfB - - index of the second object
    
    Throws:
    
    RuntimeException - if one or both indexes are out of bounds
    
    Author:
    
    cug - Jan 7, 2008
  - swapObjectWithObjectAtIndexInArray
```
@Deprecated
public static <T> void swapObjectWithObjectAtIndexInArray(NSMutableArray<T> array,
                                                                      T a,
                                                                      int indexOfB)
```
    Deprecated. use swapObjects(NSMutableArray, Object, int) instead
    
    Swaps the object a with the object at the given index
    
    Parameters:
    
    array - the array
    
    a - - first object
    
    indexOfB - - index of second object
    
    Author:
    
    edgar - Apr 14, 2008
  - swapObjects
```
public static <T> void swapObjects(NSMutableArray<T> array,
                                   int indexA,
                                   int indexB)
```
    Swaps two objects at the given indexes in an array inplace.
    
    Type Parameters:
    
    T - class of array elements
    
    Parameters:
    
    array - an array
    
    indexA - index of the first object
    
    indexB - index of the second object
  - swapObjects
```
public static <T> void swapObjects(NSMutableArray<T> array,
                                   T a,
                                   int indexB)
```
    Swaps the object a with the object at the given index in an array inplace.
    
    Type Parameters:
    
    T - class of array elements
    
    Parameters:
    
    array - an array
    
    a - the first object
    
    indexB - index of the second object
  - swapObjects
```
public static <T> void swapObjects(NSMutableArray<T> array,
                                   T a,
                                   T b)
```
    Swaps the given objects in an array inplace.
    
    Type Parameters:
    
    T - class of array elements
    
    Parameters:
    
    array - an array
    
    a - the first object
    
    b - the second object
  - swapObjects
```
public static <T> NSArray<T> swapObjects(NSArray<T> array,
                                         int indexA,
                                         int indexB)
```
    Swaps two objects at the given indexes in an array and returns a new modified array.
    
    Type Parameters:
    
    T - class of array elements
    
    Parameters:
    
    array - an array
    
    indexA - index of the first object
    
    indexB - index of the second object
    
    Returns:
    
    array with swapped objects
  - swapObjects
```
public static <T> NSArray<T> swapObjects(NSArray<T> array,
                                         T a,
                                         int indexB)
```
    Swaps the object a with the object at the given index in an array and returns a new modified array.
    
    Type Parameters:
    
    T - class of array elements
    
    Parameters:
    
    array - an array
    
    a - the first object
    
    indexB - index of the second object
    
    Returns:
    
    array with swapped objects
  - swapObjects
```
public static <T> NSArray<T> swapObjects(NSArray<T> array,
                                         T a,
                                         T b)
```
    Swaps the objects in an array and returns a new modified array.
    
    Type Parameters:
    
    T - class of array elements
    
    Parameters:
    
    array - an array
    
    a - the first object
    
    b - the second object
    
    Returns:
    
    array with swapped objects
  - deepClone
```
public static <T> NSArray<T> deepClone(NSArray<T> array,
                                       boolean onlyCollections)
```
    Returns a deep clone of the given array. A deep clone will attempt to clone the values of this array as well as the array itself.
    
    Type Parameters:
    
    T - class of array elements
    
    Parameters:
    
    array - the array to clone
    
    onlyCollections - if true, only collections in this array will be cloned, not individual values
    
    Returns:
    
    a deep clone of array
  - deepClone
```
@Deprecated
public static <T> NSSet<T> deepClone(NSSet<T> set,
                                                 boolean onlyCollections)
```
    Deprecated. user ERXSetUtilities.deepClone(NSSet, boolean) instead
    
    Returns a deep clone of the given set. A deep clone will attempt to clone the values of this set as well as the set itself.
    
    Parameters:
    
    set - the set to clone
    
    onlyCollections - if true, only collections in this array will be cloned, not individual values
    
    Returns:
    
    a deep clone of set
  - arrayIsNullOrEmpty
```
public static boolean arrayIsNullOrEmpty(Collection<?> array)
```
    Check if an array is null or empty.
    
    配列が null か空かをチェックします
    
    Parameters:
    
    array -
    an array
    
    文字列配列
    
    Returns:
    
    true if array is either null or empty
    
    配列が null か空の場合は true が戻ります
  - arrayToLogstring
```
public static String arrayToLogstring(Collection<String> array)
```
    To create oneLine Log for an NSArray<String>
    
    NSArray 配列をログとして出力する時に複数行に渡らないで、一行で収まるように
    
    Parameters:
    
    array -
    an array
    
    文字列配列
    
    Returns:
    
    change a NSArray to String
    
    NSArray を String に変換した行

Class ERXArrayUtilities

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

NULL_GROUPING_KEY

Constructor Detail

ERXArrayUtilities

Method Detail

setFromArray

sortSelectorWithKey

arrayGroupedByKeyPath

arrayGroupedByKeyPath

arrayGroupedByKeyPath

arrayGroupedByKeyPath

arrayGroupedByKeyPath

arrayGroupedByKeyPath

arrayGroupedByToManyKeyPath

arrayGroupedByToManyKeyPath

arrayGroupedByToManyKeyPath

arrayGroupedByToManyKeyPath

arrayGroupedByToManyKeyPath

arrayGroupedByToManyKeyPath

arraysAreIdenticalSets

filteredArrayWithQualifierEvaluation

filteredArrayWithQualifierEvaluation

enumerationHasMatchWithQualifierEvaluation

iteratorHasMatchWithQualifierEvaluation

filteredArrayWithQualifierEvaluation

arrayWithoutDuplicateKeyValue

arrayWithoutDuplicateKeyValue

arrayMinusArray

arrayMinusObject

arrayByAddingObjectsFromArrayWithoutDuplicates

arrayByRemovingFirstObject

safeAddObject

addObjectsFromArrayWithoutDuplicates

flatten

flatten

arrayFromPropertyList

valuesForKeyPaths

firstObject

indexOfFirstObjectWithValueForKeyPath

indexOfFirstObjectWithValueForKeyPath

firstObjectWithValueForKeyPath

firstObjectWithValueForKeyPath

objectsWithValueForKeyPath

objectsWithValueForKeyPath

indexOfObjectUsingEqualator

sortedMutableArraySortedWithKey

sortedArraySortedWithKey

sortedArraySortedWithKey

sortedArraySortedWithKeys

sortArrayWithKey

sortArrayWithKey

initialize

median

stdDev

distinct

arrayWithoutDuplicates

batchedArrayWithSize

filteredArrayWithEntityFetchSpecification

filteredArrayWithEntityFetchSpecification

shiftObjectLeft

shiftObjectRight

arrayContainsAnyObjectFromArray

arrayContainsArray

intersectingElements

reverse

friendlyDisplayForKeyPath

arrayForKeysPath

removeNullValues

removeNullValues

objectArrayCastToStringArray

objectArrayToString

objectArrayToString

objectArraysToString

removeNullValuesFromEnd