Up

# NSArray class reference

### Authors

Andrew Kachites McCallum (`mccallum@gnu.ai.mit.edu`)
Adam Fedor (`fedor@boulder.colorado.edu`)
Richard Frith-Macdonald (`richard@brainstorm.co.uk`)

Copyright: (C) 1995-2015 Free Software Foundation, Inc.

### Contents -

1. Software documentation for the NSArray class
2. Software documentation for the NSMutableArray class

# Software documentation for the NSArray class

## NSArray : NSObject

> Declared in:
>   Foundation/NSArray.h

> Conforms to:
>   NSCoding
>   NSCopying
>   NSMutableCopying
>   NSFastEnumeration

Availability: OpenStep
A simple, low overhead, ordered container for objects. All the objects in the container are retained by it. The container may not contain `nil` (though it may contain [NSNull +null] ).
Method summary

- -addObserver:toObjectsAtIndexes:forKeyPath:options:context:
- -removeObserver:fromObjectsAtIndexes:forKeyPath:
- +array
- +arrayWithArray:
- +arrayWithContentsOfFile:
- +arrayWithContentsOfURL:
- +arrayWithObject:
- +arrayWithObjects:,...
- +arrayWithObjects:count:
- -arrayByAddingObject:
- -arrayByAddingObjectsFromArray:
- -componentsJoinedByString:
- -containsObject:
- -count
- -description
- -descriptionWithLocale:
- -descriptionWithLocale:indent:
- -enumerateObjectsAtIndexes:options:usingBlock:
- -enumerateObjectsUsingBlock:
- -enumerateObjectsWithOptions:usingBlock:
- -firstObject
- -firstObjectCommonWithArray:
- -getObjects:
- -getObjects:range:
- -indexOfObject:
- -indexOfObject:inRange:
- -indexOfObject:inSortedRange:options:usingComparator:
- -indexOfObjectAtIndexes:options:passingTest:
- -indexOfObjectIdenticalTo:
- -indexOfObjectIdenticalTo:inRange:
- -indexOfObjectPassingTest:
- -indexOfObjectWithOptions:passingTest:
- -indexesOfObjectsAtIndexes:options:passingTest:
- -indexesOfObjectsPassingTest:
- -indexesOfObjectsWithOptions:passingTest:
- -init
- -initWithArray:
- -initWithArray:copyItems:
- -initWithContentsOfFile:
- -initWithContentsOfURL:
- -initWithObjects:,...
- -initWithObjects:count:
- -isEqualToArray:
- -lastObject
- -makeObjectsPerform:
- -makeObjectsPerform:withObject:
- -makeObjectsPerformSelector:
- -makeObjectsPerformSelector:withObject:
- -objectAtIndex:
- -objectAtIndexedSubscript:
- -objectEnumerator
- -objectsAtIndexes:
- -pathsMatchingExtensions:
- -reverseObjectEnumerator
- -setValue:forKey:
- -sortedArrayHint
- -sortedArrayUsingComparator:
- -sortedArrayUsingFunction:context:
- -sortedArrayUsingFunction:context:hint:
- -sortedArrayUsingSelector:
- -sortedArrayWithOptions:usingComparator:
- -subarrayWithRange:
- -valueForKey:
- -writeToFile:atomically:
- -writeToURL:atomically:

### array

+ (instancetype) array;
Availability: OpenStep
Returns an empty autoreleased array.

### arrayWithArray:

+ (instancetype) arrayWithArray: (NSArray*)array;
Availability: OpenStep
Returns a new autoreleased NSArray instance containing all the objects from array , in the same order as the original.

### arrayWithContentsOfFile:

+ (instancetype) arrayWithContentsOfFile: (NSString*)file;
Availability: OpenStep
Returns an autoreleased array based upon the file. The new array is created using [NSObject +allocWithZone:] and initialised using the [NSArray -initWithContentsOfFile:] method. See the documentation for those methods for more detail.

### arrayWithContentsOfURL:

+ (instancetype) arrayWithContentsOfURL: (NSURL*)aURL;
Availability: MacOS-X 10.0.0
Returns an autoreleased array from the contents of aURL. The new array is created using [NSObject +allocWithZone:] and initialised using the -initWithContentsOfURL: method. See the documentation for those methods for more detail.

### arrayWithObject:

+ (instancetype) arrayWithObject: (id)anObject;
Availability: OpenStep
Returns an autoreleased array containing anObject.

### arrayWithObjects: ,...

+ (instancetype) arrayWithObjects: (id)firstObject,...;
Availability: OpenStep
Returns an autoreleased array containing the list of objects, preserving order.

### arrayWithObjects: count:

+ (instancetype) arrayWithObjects: (const id[])objects count: (NSUInteger)count;
Availability: OpenStep
Returns an autoreleased array containing the specified objects, preserving order.

### arrayByAddingObject:

- (GS_GENERIC_CLASS(NSArray,ElementT)*) arrayByAddingObject: (id)anObject;
Availability: OpenStep
Returns an autoreleased array formed from the contents of the receiver and adding anObject as the last item.

### arrayByAddingObjectsFromArray:

- (GS_GENERIC_CLASS(NSArray,ElementT)*) arrayByAddingObjectsFromArray: (NSArray*)anotherArray;
Availability: OpenStep
Returns a new array which is the concatenation of self and otherArray (in this precise order).

### componentsJoinedByString:

- (NSString*) componentsJoinedByString: (NSString*)separator;
Availability: OpenStep
Returns a string formed by concatenating the objects in the receiver, with the specified separator string inserted between each part.

### containsObject:

- (BOOL) containsObject: (id)anObject;
Availability: OpenStep
Returns `YES` if anObject belongs to self. No otherwise.
The [NSObject -isEqual:] method of anObject is used to test for equality.

### count

- (NSUInteger) count;
Availability: OpenStep
Subclasses must override this method.
Returns the number of elements contained in the receiver.

### description

- (NSString*) description;
Availability: OpenStep
Returns the result of invoking -descriptionWithLocale:indent: with a `nil` locale and zero indent.

### descriptionWithLocale:

- (NSString*) descriptionWithLocale: (id)locale;
Availability: OpenStep
Returns the result of invoking -descriptionWithLocale:indent: with a zero indent.

### descriptionWithLocale: indent:

- (NSString*) descriptionWithLocale: (id)locale indent: (NSUInteger)level;
Availability: OpenStep
Returns the receiver as a text property list in the traditional format.
See [NSString -propertyList] for details.
If locale is `nil`, no formatting is done, otherwise entries are formatted according to the locale, and indented according to level.
Unless locale is `nil`, a level of zero indents items by four spaces, while a level of one indents them by a tab.
The items in the property list string appear in the same order as they appear in the receiver.

### enumerateObjectsAtIndexes: options: usingBlock:

- (void) enumerateObjectsAtIndexes: (NSIndexSet*)indexSet options: (NSEnumerationOptions)opts usingBlock: (GSEnumeratorBlock)block;
Availability: MacOS-X 10.6.0
Enumerate over the specified indexes in the collection using the given block. The first argument is the object and the second is the index in the array. The final argument is a pointer to a BOOL indicating whether the enumeration should stop. Setting this to `YES` will interrupt the enumeration. The opts argument is a bitfield. Setting the NSNSEnumerationConcurrent flag specifies that it is thread-safe. The NSEnumerationReverse bit specifies that it should be enumerated in reverse order.

### enumerateObjectsUsingBlock:

- (void) enumerateObjectsUsingBlock: (GSEnumeratorBlock)aBlock;
Availability: MacOS-X 10.6.0
Enumerate over the collection using the given block. The first argument is the object and the second is the index in the array. The final argument is a pointer to a BOOL indicating whether the enumeration should stop. Setting this to `YES` will interrupt the enumeration.

### enumerateObjectsWithOptions: usingBlock:

- (void) enumerateObjectsWithOptions: (NSEnumerationOptions)opts usingBlock: (GSEnumeratorBlock)aBlock;
Availability: MacOS-X 10.6.0
Enumerate over the collection using the given block. The first argument is the object and the second is the index in the array. The final argument is a pointer to a BOOL indicating whether the enumeration should stop. Setting this to `YES` will interrupt the enumeration. The opts argument is a bitfield. Setting the NSNSEnumerationConcurrent flag specifies that it is thread-safe. The NSEnumerationReverse bit specifies that it should be enumerated in reverse order.

### firstObject

- (GS_GENERIC_TYPE(ElementT)) firstObject;
Availability: MacOS-X 10.6.0
Returns the first object in the receiver, or `nil` if the receiver is empty.

### firstObjectCommonWithArray:

- (GS_GENERIC_TYPE(ElementT)) firstObjectCommonWithArray: (NSArray*)otherArray;
Availability: OpenStep
Returns the first object found in the receiver (starting at index 0) which is present in the otherArray as determined by using the -containsObject: method.

### getObjects:

- (void) getObjects: (__unsafe_unretained id[])aBuffer;
Availability: OpenStep
Copies the objects from the receiver to aBuffer, which must be an area of memory large enough to hold them.

### getObjects: range:

- (void) getObjects: (__unsafe_unretained id[])aBuffer range: (NSRange)aRange;
Availability: OpenStep
Copies the objects from the range aRange of the receiver to aBuffer, which must be an area of memory large enough to hold them.

### indexOfObject:

- (NSUInteger) indexOfObject: (id)anObject;
Availability: OpenStep
Returns the index of the first object found in the receiver which is equal to anObject (using anObject's [NSObject -isEqual:] method). Returns NSNotFound on failure.

### indexOfObject: inRange:

- (NSUInteger) indexOfObject: (id)anObject inRange: (NSRange)aRange;
Availability: OpenStep
Returns the index of the first object found in aRange of receiver which is equal to anObject (using anObject's [NSObject -isEqual:] method). Returns NSNotFound on failure.

### indexOfObject: inSortedRange: options: usingComparator:

- (NSUInteger) indexOfObject: (id)key inSortedRange: (NSRange)range options: (NSBinarySearchingOptions)options usingComparator: (NSComparator)comparator;
Availability: MacOS-X 10.6.0
Performs a binary search of the array within the specified range for the index of an object equal to obj according to cmp. If NSBinarySearchingInsertionIndex is specified, searches for the index at which such an object should be inserted.

### indexOfObjectAtIndexes: options: passingTest:

- (NSUInteger) indexOfObjectAtIndexes: (NSIndexSet*)indexSet options: (NSEnumerationOptions)opts passingTest: (GSPredicateBlock)predicate;
Availability: MacOS-X 10.6.0
Returns the index of the first object in the specified range in a collection that matches the condition specified by the block. The opts argument is a bitfield. Setting the NSNSEnumerationConcurrent flag specifies that it is thread-safe. The NSEnumerationReverse bit specifies that it should be enumerated in reverse order.

### indexOfObjectIdenticalTo:

- (NSUInteger) indexOfObjectIdenticalTo: (id)anObject;
Availability: OpenStep
Returns the index of the specified object in the receiver, or NSNotFound if the object is not present.

### indexOfObjectIdenticalTo: inRange:

- (NSUInteger) indexOfObjectIdenticalTo: (id)anObject inRange: (NSRange)aRange;
Availability: OpenStep
Returns the index of the specified object in the range of the receiver, or NSNotFound if the object is not present.

### indexOfObjectPassingTest:

- (NSUInteger) indexOfObjectPassingTest: (GSPredicateBlock)predicate;
Availability: MacOS-X 10.6.0
Returns the index of the first object in the array that matches the condition specified by the block.

### indexOfObjectWithOptions: passingTest:

- (NSUInteger) indexOfObjectWithOptions: (NSEnumerationOptions)opts passingTest: (GSPredicateBlock)predicate;
Availability: MacOS-X 10.6.0
Returns the index of the first object in the array that matches the condition specified by the block. The opts argument is a bitfield. Setting the NSNSEnumerationConcurrent flag specifies that it is thread-safe. The NSEnumerationReverse bit specifies that it should be enumerated in reverse order.

### indexesOfObjectsAtIndexes: options: passingTest:

- (NSIndexSet*) indexesOfObjectsAtIndexes: (NSIndexSet*)indexSet options: (NSEnumerationOptions)opts passingTest: (GSPredicateBlock)predicate;
Availability: MacOS-X 10.6.0
Returns the indexes of the objects in a collection that match the condition specified by the block and are in the range specified by the index set. The opts argument is a bitfield. Setting the NSNSEnumerationConcurrent flag specifies that it is thread-safe. The NSEnumerationReverse bit specifies that it should be enumerated in reverse order.

### indexesOfObjectsPassingTest:

- (NSIndexSet*) indexesOfObjectsPassingTest: (GSPredicateBlock)predicate;
Availability: MacOS-X 10.6.0
Returns the indexes of the objects in a collection that match the condition specified by the block.

### indexesOfObjectsWithOptions: passingTest:

- (NSIndexSet*) indexesOfObjectsWithOptions: (NSEnumerationOptions)opts passingTest: (GSPredicateBlock)predicate;
Availability: MacOS-X 10.6.0
Returns the indexes of the objects in a collection that match the condition specified by the block. The opts argument is a bitfield. Setting the NSNSEnumerationConcurrent flag specifies that it is thread-safe. The NSEnumerationReverse bit specifies that it should be enumerated in reverse order.

### init

- (instancetype) init;
Availability: OpenStep

In MacOS-X class clusters do not have designated initialisers, and there is a general rule that -init is treated as the designated initialiser of the class cluster, but that other intitialisers may not work s expected an would need to be individually overridden in any subclass.

GNUstep tries to make it easier to subclass a class cluster, by making class clusters follow the same convention as normal classes, so the designated initialiser is the richest initialiser. This means that all other initialisers call the documented designated initialiser (which calls -init only for MacOS-X compatibility), and anyone writing a subclass only needs to override that one initialiser in order to have all the other ones work.

For MacOS-X compatibility, you may also need to override various other initialisers. Exactly which ones, you will need to determine by trial on a MacOS-X system... and may vary between releases of MacOS-X. So to be safe, on MacOS-X you probably need to re-implement all the class cluster initialisers you might use in conjunction with your subclass.

### initWithArray:

- (instancetype) initWithArray: (NSArray*)array;
Availability: OpenStep
Initialize the receiver with the contents of array. The order of array is preserved.
Invokes -initWithObjects:count:

### initWithArray: copyItems:

- (instancetype) initWithArray: (NSArray*)array copyItems: (BOOL)shouldCopy;
Availability: MacOS-X 10.0.0
Initialize the receiver with the contents of array. The order of array is preserved.
If shouldCopy is `YES` then the objects are copied rather than simply retained.
Invokes -initWithObjects:count:

### initWithContentsOfFile:

- (instancetype) initWithContentsOfFile: (NSString*)file;
Availability: OpenStep

Initialises the array with the contents of the specified file, which must contain an array in property-list format.

In GNUstep, the property-list format may be either the OpenStep format (ASCII data), or the MacOS-X format (UTF-8 XML data)... this method will recognise which it is.

If there is a failure to load the file for any reason, the receiver will be released, the method will return `nil`, and a warning may be logged.

Works by invoking [NSString -initWithContentsOfFile:] and [NSString -propertyList] then checking that the result is an array.

### initWithContentsOfURL:

- (instancetype) initWithContentsOfURL: (NSURL*)aURL;
Availability: MacOS-X 10.0.0

Initialises the array with the contents of the specified URL, which must contain an array in property-list format.

In GNUstep, the property-list format may be either the OpenStep format (ASCII data), or the MacOS-X format (UTF8 XML data)... this method will recognise which it is.

If there is a failure to load the URL for any reason, the receiver will be released, the method will return `nil`, and a warning may be logged.

Works by invoking [NSString -initWithContentsOfURL:] and [NSString -propertyList] then checking that the result is an array.

### initWithObjects: ,...

- (instancetype) initWithObjects: (id)firstObject,...;
Availability: OpenStep
Initialize the array the list of objects.
May change the value of self before returning it.

### initWithObjects: count:

- (instancetype) initWithObjects: (const id[])objects count: (NSUInteger)count;
Availability: OpenStep
This is a designated initialiser for the class.
Subclasses must override this method.
This should initialize the array with count (may be zero) objects.
Retains each object placed in the array.
Calls -init (which does nothing but maintain MacOS-X compatibility), and needs to be re-implemented in subclasses in order to have all other initialisers work.

### isEqualToArray:

- (BOOL) isEqualToArray: (NSArray*)otherArray;
Availability: OpenStep
Returns `YES` if the receiver is equal to otherArray, `NO` otherwise.

### lastObject

- (GS_GENERIC_TYPE(ElementT)) lastObject;
Availability: OpenStep
Returns the last object in the receiver, or `nil` if the receiver is empty.

### makeObjectsPerform:

- (void) makeObjectsPerform: (SEL)aSelector;
Availability: OPENSTEP 4.0.0 removed at MacOS-X 10.0.0
Obsolete version of -makeObjectsPerformSelector:

### makeObjectsPerform: withObject:

- (void) makeObjectsPerform: (SEL)aSelector withObject: (id)argument;
Availability: OPENSTEP 4.0.0 removed at MacOS-X 10.0.0
Obsolete version of -makeObjectsPerformSelector:withObject:

### makeObjectsPerformSelector:

- (void) makeObjectsPerformSelector: (SEL)aSelector;
Availability: MacOS-X 10.0.0
Makes each object in the array perform aSelector.
This is done sequentially from the first to the last object.

### makeObjectsPerformSelector: withObject:

- (void) makeObjectsPerformSelector: (SEL)aSelector withObject: (id)arg;
Availability: MacOS-X 10.0.0
Makes each object in the array perform aSelector with arg.
This is done sequentially from the first to the last object.

### objectAtIndex:

- (GS_GENERIC_TYPE(ElementT)) objectAtIndex: (NSUInteger)index;
Availability: OpenStep
Subclasses must override this method.
Returns the object at the specified index. Raises an exception of the index is beyond the array.

### objectAtIndexedSubscript:

- (GS_GENERIC_TYPE(ElementT)) objectAtIndexedSubscript: (NSUInteger)anIndex;
Availability: OpenStep
Accessor for subscripting. This is called by the compiler when you write code like anArray[12]. It should not be called directly.

### objectEnumerator

- (GS_GENERIC_CLASS(NSEnumerator,ElementT)*) objectEnumerator;
Availability: OpenStep
Returns an enumerator describing the array sequentially from the first to the last element.
If you use a mutable subclass of NSArray, you should not modify the array during enumeration.

### objectsAtIndexes:

- (GS_GENERIC_CLASS(NSArray,ElementT)*) objectsAtIndexes: (NSIndexSet*)indexes;
Availability: MacOS-X 10.4.0
Description forthcoming.

### pathsMatchingExtensions:

- (GS_GENERIC_CLASS(NSArray,NSString*)*) pathsMatchingExtensions: (NSArray*)extensions;
Availability: OpenStep
Assumes that the receiver is an array of paths, and returns an array formed by selecting the subset of those patch matching the specified array of extensions.

### reverseObjectEnumerator

- (GS_GENERIC_CLASS(NSEnumerator,ElementT)*) reverseObjectEnumerator;
Availability: OpenStep
Returns an enumerator describing the array sequentially from the last to the first element.
If you use a mutable subclass of NSArray, you should not modify the array during enumeration.

### setValue: forKey:

- (void) setValue: (id)value forKey: (NSString*)key;
Availability: MacOS-X 10.0.0
Call setValue:forKey: on each of the receiver's items with the value and key.

### sortedArrayHint

- (NSData*) sortedArrayHint;
Availability: OpenStep
Subclasses may provide a hint for sorting... The default GNUstep implementation just returns `nil`.

### sortedArrayUsingComparator:

- (GS_GENERIC_CLASS(NSArray,ElementT)*) sortedArrayUsingComparator: (NSComparator)comparator;
Availability: MacOS-X 10.6.0
Returns a sorted array using the comparator to determine the order of objects.

### sortedArrayUsingFunction: context:

- (GS_GENERIC_CLASS(NSArray,ElementT)*) sortedArrayUsingFunction: (NSComparisonResult(*)(id,id,void*))comparator context: (void*)context;
Availability: OpenStep
Returns an autoreleased array in which the objects are ordered according to a sort with comparator. This invokes -sortedArrayUsingFunction:context:hint: with a `nil` hint.

### sortedArrayUsingFunction: context: hint:

- (GS_GENERIC_CLASS(NSArray,ElementT)*) sortedArrayUsingFunction: (NSComparisonResult(*)(id,id,void*))comparator context: (void*)context hint: (NSData*)hint;
Availability: OpenStep
Returns an autoreleased array in which the objects are ordered according to a sort with comparator, where the comparator function is passed two objects to compare, and the context as the third argument. The hint argument is currently ignored, and may be `nil`.

### sortedArrayUsingSelector:

- (GS_GENERIC_CLASS(NSArray,ElementT)*) sortedArrayUsingSelector: (SEL)comparator;
Availability: OpenStep
Returns an autoreleased array in which the objects are ordered according to a sort with comparator.

### sortedArrayWithOptions: usingComparator:

- (GS_GENERIC_CLASS(NSArray,ElementT)*) sortedArrayWithOptions: (NSSortOptions)options usingComparator: (NSComparator)comparator;
Availability: MacOS-X 10.6.0
Returns a sorted array using the block to determine the order of objects. The opts argument is a bitfield. Setting the NSSortConcurrent flag specifies that it is thread-safe. The NSSortStable bit specifies that it should keep equal objects in the same order.

### subarrayWithRange:

- (GS_GENERIC_CLASS(NSArray,ElementT)*) subarrayWithRange: (NSRange)aRange;
Availability: OpenStep
Returns a subarray of the receiver containing the objects found in the specified range aRange.

### valueForKey:

- (GS_GENERIC_TYPE(ElementT)) valueForKey: (NSString*)key;
Availability: MacOS-X 10.0.0
This overrides NSObjects implementation of this method. This method returns an array of objects returned by invoking -valueForKey: for each item in the receiver, substituting NSNull for `nil`. A special case: the key "count" is not forwarded to each object of the receiver but returns the number of objects of the receiver.

### writeToFile: atomically:

- (BOOL) writeToFile: (NSString*)path atomically: (BOOL)useAuxiliaryFile;
Availability: OpenStep

Writes the contents of the array to the file specified by path. The file contents will be in property-list format... under GNUstep this is either OpenStep style (ASCII characters using \U hexadecimal escape sequences for unicode), or MacOS-X style (XML in the UTF8 character set).

If the useAuxiliaryFile flag is `YES`, the file write operation is atomic... the data is written to a temporary file, which is then renamed to the actual file name.

If the conversion of data into the correct property-list format fails or the write operation fails, the method returns `NO`, otherwise it returns `YES`.

NB. The fact that the file is in property-list format does not necessarily mean that it can be used to reconstruct the array using the -initWithContentsOfFile: method. If the original array contains non-property-list objects, the descriptions of those objects will have been written, and reading in the file as a property-list will result in a new array containing the string descriptions.

### writeToURL: atomically:

- (BOOL) writeToURL: (NSURL*)url atomically: (BOOL)useAuxiliaryFile;
Availability: MacOS-X 10.0.0

Writes the contents of the array to the specified url. This functions just like -writeToFile:atomically: except that the output may be written to any URL, not just a local file.

# Software documentation for the NSMutableArray class

## NSMutableArray : NSArray

> Declared in:
>   Foundation/NSArray.h

Availability: OpenStep
`NSMutableArray` is the mutable version of NSArray . It provides methods for altering the contents of the array.
Method summary

- +arrayWithCapacity:
- -addObject:
- -addObjectsFromArray:
- -exchangeObjectAtIndex:withObjectAtIndex:
- -initWithCapacity:
- -insertObject:atIndex:
- -insertObjects:atIndexes:
- -removeAllObjects
- -removeLastObject
- -removeObject:
- -removeObject:inRange:
- -removeObjectAtIndex:
- -removeObjectIdenticalTo:
- -removeObjectIdenticalTo:inRange:
- -removeObjectsAtIndexes:
- -removeObjectsFromIndices:numIndices:
- -removeObjectsInArray:
- -removeObjectsInRange:
- -replaceObjectAtIndex:withObject:
- -replaceObjectsAtIndexes:withObjects:
- -replaceObjectsInRange:withObjectsFromArray:
- -replaceObjectsInRange:withObjectsFromArray:range:
- -setArray:
- -setObject:atIndexedSubscript:
- -sortUsingComparator:
- -sortUsingFunction:context:
- -sortUsingSelector:
- -sortWithOptions:usingComparator:

### arrayWithCapacity:

+ (instancetype) arrayWithCapacity: (NSUInteger)numItems;
Availability: OpenStep
Creates an autoreleased mutable array able to store at least numItems. See the -initWithCapacity: method.

### addObject:

- (void) addObject: (id)anObject;
Availability: OpenStep
Subclasses must override this method.
Adds anObject at the end of the array, thus increasing the size of the array. The object is retained upon addition.

### addObjectsFromArray:

- (void) addObjectsFromArray: (NSArray*)otherArray;
Availability: OpenStep
Adds each object from otherArray to the receiver, in first to last order.

### exchangeObjectAtIndex: withObjectAtIndex:

- (void) exchangeObjectAtIndex: (NSUInteger)i1 withObjectAtIndex: (NSUInteger)i2;
Availability: MacOS-X 10.0.0
Swaps the positions of two objects in the array. Raises an exception if either array index is out of bounds.

### initWithCapacity:

- (instancetype) initWithCapacity: (NSUInteger)numItems;
Availability: OpenStep
This is a designated initialiser for the class.
Subclasses must override this method.
Initialise the array with the specified capacity ... this should ensure that the array can have numItems added efficiently.
Calls -init (which does nothing but maintain MacOS-X compatibility), and needs to be re-implemented in subclasses in order to have all other initialisers work.

### insertObject: atIndex:

- (void) insertObject: (id)anObject atIndex: (NSUInteger)index;
Availability: OpenStep
Subclasses must override this method.
Inserts an object into the receiver at the specified location.
Raises an exception if given an array index which is too large.
The size of the array increases by one.
The object is retained by the array.

### insertObjects: atIndexes:

- (void) insertObjects: (NSArray*)objects atIndexes: (NSIndexSet*)indexes;
Availability: MacOS-X 10.4.0
Inserts the values from the objects array into the receiver at the locations given by the indexes set.
The values are inserted in the same order that they appear in the array.

### removeAllObjects

- (void) removeAllObjects;
Availability: OpenStep
Removes all objects from the receiver, leaving an empty array.

### removeLastObject

- (void) removeLastObject;
Availability: OpenStep
Removes the last object in the array. Raises an exception if the array is already empty.

### removeObject:

- (void) removeObject: (id)anObject;
Availability: OpenStep
Removes all occurrences of anObject (found by anObject's [NSObject -isEqual:] method) from the receiver.

### removeObject: inRange:

- (void) removeObject: (id)anObject inRange: (NSRange)aRange;
Availability: OpenStep
Removes all occurrences of anObject (found by the [NSObject -isEqual:] method of anObject) aRange in the receiver.

### removeObjectAtIndex:

- (void) removeObjectAtIndex: (NSUInteger)index;
Availability: OpenStep
Subclasses must override this method.
Removes an object from the receiver at the specified location.
The size of the array decreases by one.
Raises an exception if given an array index which is too large.

### removeObjectIdenticalTo:

- (void) removeObjectIdenticalTo: (id)anObject;
Availability: OpenStep
Removes all occurrences of anObject (found by pointer equality) from the receiver.

### removeObjectIdenticalTo: inRange:

- (void) removeObjectIdenticalTo: (id)anObject inRange: (NSRange)aRange;
Availability: OpenStep
Removes all occurrences of anObject (found by pointer equality) from aRange in the receiver.

### removeObjectsAtIndexes:

- (void) removeObjectsAtIndexes: (NSIndexSet*)indexes;
Availability: OpenStep
Removes objects from the receiver at the indices supplied by an NSIndexSet

### removeObjectsFromIndices: numIndices:

- (void) removeObjectsFromIndices: (NSUInteger*)indices numIndices: (NSUInteger)count;
Availability: OpenStep
Supplied with a C array of indices containing count values, this method removes all corresponding objects from the receiver. The objects are removed in such a way that the removal is safe irrespective of the order in which they are specified in the indices array.

### removeObjectsInArray:

- (void) removeObjectsInArray: (NSArray*)otherArray;
Availability: OpenStep
Removes from the receiver, all the objects present in otherArray, as determined by using the [NSObject -isEqual:] method.

### removeObjectsInRange:

- (void) removeObjectsInRange: (NSRange)aRange;
Availability: OpenStep
Removes all the objects in aRange from the receiver.

### replaceObjectAtIndex: withObject:

- (void) replaceObjectAtIndex: (NSUInteger)index withObject: (id)anObject;
Availability: OpenStep
Subclasses must override this method.
Places an object into the receiver at the specified location.
Raises an exception if given an array index which is too large.
The object is retained by the array.

### replaceObjectsAtIndexes: withObjects:

- (void) replaceObjectsAtIndexes: (NSIndexSet*)indexes withObjects: (NSArray*)objects;
Availability: MacOS-X 10.4.0
Replaces the values in the receiver at the locations given by the indexes set with values from the objects array.

### replaceObjectsInRange: withObjectsFromArray:

- (void) replaceObjectsInRange: (NSRange)aRange withObjectsFromArray: (NSArray*)anArray;
Availability: OpenStep
Replaces objects in the receiver with those from anArray.
Raises an exception if given a range extending beyond the array.

### replaceObjectsInRange: withObjectsFromArray: range:

- (void) replaceObjectsInRange: (NSRange)aRange withObjectsFromArray: (NSArray*)anArray range: (NSRange)anotherRange;
Availability: OpenStep
Replaces objects in the receiver with some of those from anArray.
Raises an exception if given a range extending beyond the array.

### setArray:

- (void) setArray: (NSArray*)otherArray;
Availability: OpenStep
Sets the contents of the receiver to be identical to the contents of otherArray.

### setObject: atIndexedSubscript:

- (void) setObject: (id)anObject atIndexedSubscript: (NSUInteger)anIndex;
Availability: MacOS-X 10.8.0
Set method called by the compiler with array subscripting.
Replaces the object at anIndex or, if anIndex is the length of the array, this method appends abObject to the array.

### sortUsingComparator:

- (void) sortUsingComparator: (NSComparator)comparator;
Availability: MacOS-X 10.6.0
Sorts the array using the specified comparator block.

### sortUsingFunction: context:

- (void) sortUsingFunction: (NSComparisonResult(*)(id,id,void*))compare context: (void*)context;
Availability: OpenStep
Sorts the array according to the supplied compare function with the context information.

### sortUsingSelector:

- (void) sortUsingSelector: (SEL)comparator;
Availability: OpenStep
Sorts the array according to the supplied comparator.

### sortWithOptions: usingComparator:

- (void) sortWithOptions: (NSSortOptions)options usingComparator: (NSComparator)comparator;
Availability: MacOS-X 10.6.0
Sorts the array using the specified comparator block and options.

Up