Brief Intro to Collections of Foundation Frameworks

Collections

The Foundation Framework collections classes manage collections of objects. Most collection classes have both an immutable and a mutable version. NSArray and NSMutableArray manage arrays, ordered collections of objects that can be of any type; the elements of an NSArray do not have to be of the same type. NSDictionary and NSMutableDictionary are used for groups of key-value pairs.NSSet, NSMutableSet, and NSCountedSet are used to manage unordered collections of objects. TheNSEnumerator and NSDirectoryEnumerator classes enumerate collections of other objects, such as arrays and dictionaries. NSIndexSet and NSMutableIndexSet manage collections of index sets(collections of unique unsigned integers used to store indexes into another data structure).NSHashTable, NSMapTable, and NSPointerArray are mutable collections that support weak relationships when using the garbage collector.

The NSHashTable, NSMapTable, and NSPointerArray classes are available for use on the Apple OS X platform only (i.e., these classes are not available for the iOS platform).

NSArray

NSArray and NSMutableArray manage ordered collections of objects that do not have to be of the same type. NSArray is immutable (the objects assigned to the array at initialization cannot be removed, although there contents can be changed). NSMutableArray allows adding or removing objects in a collection. The operations supported by NSArray include array creation and initialization, query (obtaining information about the array or retrieving its elements), finding an object in an array, object messaging to array elements, comparing arrays, and sorting an array. Many NSArray andNSMutableArray operations are executed in constant time (accessing an element, adding/removing on ends, replacing an element), whereas inserting an element in the middle of an NSMutableArraytakes linear time. The following statement uses the NSArray arrayWithObjects: convenience constructor to create an NSArray object assigned to the variable myArray initialized with NSNumberliterals.

NSArray *myArray = [NSArray arrayWithObjects:@1, @2, nil];      

Notice that the arrayWithObjects: method requires parameters with a comma-separated list of objects ending with nil. The next statement retrieves the first element of this NSArray object using the NSArray indexOfObject: method.

id num0 = [myArray objectAtIndex:0];      

The following statement returns the index of the NSNumber object (with a value of 2) in the precedingNSArray object.

NSUInteger index = [myArray indexOfObject:@2];      

NSArray also includes the following methods to persist the contents of an array to a property list and initialize an NSArray object from a property list:

- writeToFile:atomically:
- writeToURL:atomically:
- initWithContentsOfFile:
- initWithContentsOfURL:      

When persisting an array (via the writeTo... methods), its contents must all be property list objects (i.e., NSString, NSData, NSDate, NSNumber, NSArray, NSDictionary objects).

NSArray Literals

Objective-C provides language-level support for creating NSArray literals. The array is defined by a comma-separated list of objects between square brackets, prefixed by an @ character. Unlike the NSArray arrayWithObjects: and initWithObjects: methods, the list of objects used to define anNSArray literal is not required to end with a nil. The following statements are equivalent:

NSArray *myArray = [NSArray arrayWithObjects:@1, @2, nil];
NSArray *myArray = @[@1, @2];      

As with NSNumber literals, NSArray literals are not compile-time constants; they are evaluated at runtime.

NSPointerArray

NSPointerArray is a mutable collection similar to NSMutableArray that can hold arbitrary pointers and NULL values. It also allows you to manage the collection by setting the count for the array, such that if the number of elements in the collection is less than the count, then the collection is padded with NULL values; or if the number of elements in the collection is greater than the count, then the elements in the collection above the count value are removed.

NSDictionary

The NSDictionary and NSMutableDictionary classes manage collections of key/value (object) pairs. Within a collection, the value of a key is unique (i.e., it must be an object that adopts the NSCopyingprotocol and implements the hash and isEqual: methods). The operations supported by these classes include object creation and initialization, query, finding objects in the collection, filtering, comparing, and sorting the collection. The sorting options include sorting with selectors (using thekeySortedByValueUsingSelector: method), and sorting with blocks (using thekeySortedByValueUsingComparator: method). For keys with good hash functions (for example, NSString), NSDictionary operations take constant time (accessing, setting, removing an element from an NSDictionary or NSMutableDictionary). The code fragment shown in Listing 10-5 creates and initializes an NSDictionary object with two elements.

Listing 10-5.  Creating and Initializing an NSDictionary Object

NSArray *objects = @[@1, @2];
NSArray *keys = @[@"one", @"two"];
NSDictionary *myDi = [NSDictionary dictionaryWithObjects:objects];
                       withKeys:keys];      

The next statement retrieves the value from the preceding NSDictionary object that has the key"one".

id value = [myDi objectForKey:@"one"];      

As with NSArray, NSDictionary includes methods to persist the contents of a dictionary to a property list and initialize an NSDictionary object from a property list:

- writeToFile:atomically:
- writeToURL:atomically:
- initWithContentsOfFile:
- initWithContentsOfURL:      

When persisting a dictionary (via the writeTo... methods), its contents must all be property list objects (NSString, NSData, NSDate, NSNumber, NSArray, and NSDictionary objects).

NSDictionary Literals

Objective-C provides language-level support for creating NSDictionary literals. The dictionary is defined by a comma-separated list of key-value pairs between curly braces, prefixed by an @character. In each key-value pair, a colon separates the key and value. The following statements are equivalent:

NSArray *objects = @[@1, @2];
NSArray *keys = @[@"one", @"two"];
NSDictionary *myDi = [NSDictionary dictionaryWithObjects:objects];

NSDictionary *myDi = @{@"one":@1, @"two":@2};      

As with NSNumber literals, NSDictionary literals are not compile-time constants; they are evaluated at runtime.

NSMapTable

NSPointerArray is a mutable collection similar to NSDictionary that provides additional storage options. Specifically, it can store arbitrary pointers. It can also store weakly referenced keys and/or values.

NSSet

NSSet and NSMutableSet manage unordered collections of objects that do not have to be of the same type. The objects stored in an NSSet are unique. The operations supported by NSSet include creation and initialization, finding an object in a set, comparing, and sorting (using the NSSetsortedArrayUsingDescriptors: method). If the objects in the set have a good hash function, accessing an element, setting an element, and removing an element all take constant time. With a poor hash function (one that causes frequent hash collisions), these operations take up linear time.

Sets, excluding NSCountedSets, ensure that no object is represented more than once, and there is nonet effect for adding an object more than once. The following statement uses the NSSet setWithObjects: convenience constructor to create an NSSet object assigned to the variable mySetinitialized with NSNumber literals.

NSSet *mySet = [NSSet setWithObjects:@1, @2, nil];      

NSCountedSet

NSCountedSet is a mutable set that allows an object to be added multiple times (i.e., its elements aren’t required to be distinct). Each distinct object has an associated counter. An NSSet object keeps track of the number of times each distinct object is inserted and requires a corresponding object(s) to be removed the same number of times.

NSHashTable

NSHashTable is a mutable collection similar to NSSet that provides different options. Specifically, it can store arbitrary pointers. It can also store weakly referenced keys and/or values.

NSPointerFunctions

The NSPointerFunctions class defines functions for managing pointer functions. An NSHashTable ,NSMapTable , or NSPointerArray object typically uses an NSPointerFunctions instance to define behavior for the pointers it manages.