Objective-C Fundamentals

Arrays
81
If you need to modify an array after it’s been created, you must make sure you create a
mutable array. A good way to get started is by creating an empty array using the array
factory method on the NSMutableArray class instead of the NSArray class. This creates
an array that’s initially empty, but because the array is mutable, you’ll be able to
append new elements to it at runtime as desired.
NSMutableArray *array = [NSMutableArray array];
An NSMutableArray grows in size whenever you add elements to it. You can conceptually
think of the array as allocating additional memory to the array to store each element
as it’s added. But this isn’t the most efficient way to use memory. If you know
ahead of time how many elements you intend to add to the array, it’s more efficient
for the array to allocate enough memory to store all the elements in one go. As you
may expect, NSMutableArray is smart: it provides another factory method called
arrayWithCapacity: for this very case:
NSMutableArray *pets = [NSMutableArray arrayWithCapacity:50];
This code snippet creates a new NSMutableArray and internally allocates enough
memory to store a minimum of 50 elements. It’s important to note, however, that this
is only a hint as to the number of items expected to eventually be added to the array.
An array created via such a technique is perfectly able to store more than 50 elements
and will allocate additional memory once the specified capacity is exceeded.
It’s also important not to confuse the capacity of an array with its length or count.
Although the array just created has memory set aside to store at least 50 elements, if
you ask for its current size via the count message, it will indicate 0 because you still
haven’t physically added anything to it. The capacity is only a hint that allows the
NSMutableArray class to avoid excessive memory allocations. Specifying a capacity of
50 means there won’t be any additional memory allocations until at least the 51st element
is added to the array. Doing this may lead to potential performance gains and
less memory fragmentation.
Now that you know how to create an NSMutableArray instance that allows you to
dynamically modify its contents, how do you add additional elements to an array? One
answer is to use the addObject: message, which allows you to add a new element to
the end of an existing array:
[pets addObject:@"Pony"];
This snippet expands the size of the array by one element and stores the string "Pony"
in the newly added element. It’s also possible to insert an element into the middle of
an array. For this, you can use insertObject:atIndex:, which expects the array index
at which to insert the new element:
[pets insertObject:@"Hamster" atIndex:2];
When this statement is executed, every element starting from array index 2 is shifted
one place higher: the object at index 2 becomes the element at index 3, and so on.
The vacated space at index 2 is then filled by inserting the string "Hamster". Instead of