When you create an array (either an NSArray or NSMutableArray), you're working with objects, so you need to create a pointer such as the following:

NSArray *myArray;
NSMutableArray *myOtherArray;

This simply creates a pointer to an array object. To fill an array with data, you have two options. First, you can declare an array on one line and then fill that array on a second line like this:

NSArray *myArray;
myArray = [NSArray arrayWithObjects: object1,  object2, object3, nil];

A second way to fill an array with data is to declare and initialize the array on a single line:

NSArray *myArray = [NSArray arrayWithObjects: object1,  object2, object3, nil];

Although this example adds only three objects, you can add as many objects to an array as you want. Before you can add an object to an array, you must declare that object ahead of the array:

NSString *object1 = @"Hello";
NSString *object2 = @"world!";
NSNumber *object3 = [NSNumber numberWithInt:45];
NSArray *myArray = [NSArray arrayWithObjects: object1,  object2, object3, nil];

Before continuing, it's important to know exactly what's happening in this code. First, whenever you see an asterisk used in front of a variable name, your code is probably defining a pointer, and the presence of pointers almost always means you're working with an object. The first three lines of this example create three objects named object1, object2, and object3. The first two objects are string objects (NSString) and the third object is a number object (NSNumber).

Second, the square brackets are almost always used to work with objects as well. The equal sign (=) assigns a value to a variable. In this case, the value inside the square brackets gets assigned to the *myArray pointer.

To see how an array works, follow these steps:

Finding the Right Method to Use

When square brackets work with objects, the object name always appears first. In the previous example, the object is NSArray. The next question is, where did the arrayWithObjects method come from?

To find the answer, you need to remember that Apple has defined plenty of useful classes and stored them in its Cocoa framework for all programmers to use. Any time you see a class that begins with the prefix NS (which stands for NeXTSTEP), that's a clue that you're working with one of Apple's predefined classes.

Since classes almost always include properties (data) and methods (subprograms that manipulate the class's data), you can browse through Apple's Developer Documentation to find a list of all the methods and properties available for any class provided by Apple.

To find this documentation, you need to view the Developer Documentation through the Xcode Help menu. Choose Help

Figure 10-2. The NSArray class reference is available in the Developer Documentation.

Scroll through this NSArray class reference and look for a method that lets you store data in the NSArray. You may see several methods, but eventually you'll find the arrayWithObjects method listed, along with an explanation of how it works, as shown in Figure 10-3.

Figure 10-3. The arrayWithObjects method explained in the Developer Documentation

The general rule when working with classes that begin with an NS prefix is to look for the properties and methods you can use to manipulate those objects. Chances are good that Apple already provides the code you need to use, which means that instead of having to write your own code for adding data to an array (which you have to do in other programming languages), Apple lets you choose the method you need, thus reducing the amount of code you need to write and test.

StoringObjects in an Array

Now that you understand where the arrayWithObjects method came from, you can use it to store objects in the array. You must separate each object with a comma, and when you're done adding objects to the array, you must use the nil value to identify the end of the array. If you don't use nil as the last object stored in your array, you could confuse the computer and cause your program to crash.

Just the simple act of adding data to an array showed you quite a bit about the process of writing a Mac program. The biggest trick is simply knowing which methods, in different classes, you can use and how they work, which you can learn by browsing through the Developer Documentation.

Some other ways to learn about different methods available for specific classes include the following:

• Have someone show or tell you

• Find a book or web page that explains that particular method

• Study Objective-C programs written by someone else

Trying to find the right method to use can be like trying to look up a word in a dictionary when you don't know how to spell that word. The first step should be to look up the class reference for the particular object you want to manipulate, such as NSArray.

Suppose you look up a class reference and can't find the method you want. That doesn't necessarily mean that the method you want doesn't exist. Check the class reference for the object to see a list of other classes that the class inherits from. The NSArray class reference (see Figure 10-2) shows that the NSArray class inherits from the NSObject class. So if the method you want isn't available in the NSArray class reference, it might be described in the NSObject class reference.

Remember, every class contains its own methods and properties. When one class inherits from another class, that second class includes all the methods and properties of both classes. Since the NSArray class inherits from the NSObject class, the NSArray class inherits all the methods and properties from the NSObject class.

If you look up the class reference of one class, such as NSArray, in the Developer Documentation, you can view all the methods and properties unique to that particular class. If you then look up the class that the NSArray class inherits from (NSObject), you can see all the methods and properties specific to the NSObject class. However, since NSArray inherits every property and method from NSObject, NSArray winds up containing every property and method available in both NSObject and NSArray, as shown in Figure 10-4.

Figure 10-4. Objects inherit methods and properties from other classes.

After you have stored data in an array, you can always count the number of items stored in that array by using the count command:

[arrayName count];

The arrayName simply represents the name of your array, and the count command returns the number of items in that array, so the entire line of code evaluates to a single number. If arrayName held six items, the preceding code would return the number 6.

To see how to count items in an array, follow these steps:

When you store items in an array, the first item gets stored at one end of the array, the second item gets stored next to the first item, the third item gets stored next to the second item, and so on.

To keep track of all the items stored in an array, the array uses a number called an array index. The first item in an array is stored at index 0, the second item in an array is stored at index 1, and so on, as shown in Figure 10-5.

Figure 10-5. The array index identifies an item's position in an array.

To retrieve an item from an array, you need to identify that item's index position in the array. So if you wanted to retrieve the first item in the array, you would retrieve the item stored at index position 0, if you wanted to retrieve the second item in the array, you would retrieve the item stored at index position 1, and so on.

To retrieve a specific item from an array, you have to identify the array, use the objectAtIndex method, and specify the index position:

[arrayName objectAtIndex: index];

The preceding code would return whatever object was stored in the array at the designated index position. So if you created an array like this,

NSArray *myArray = [NSArray arrayWithObjects: @"Hello", @"world", "@Good-bye", nil];

you could use the following code to retrieve the second item (index position 1) in the array, which would be "world":

[myArray objectAtIndex:1];

To see how to retrieve items from an array, follow these steps:

Accessing an individual item in an array is fine when you only want that one item. However, if you want to retrieve all the items in an array, and all items stored in the array are of the same data type, you can use something called fast enumeration.

Fast enumeration lets you access every item in an array by using a modified for loop that looks like this:

for (objectType *variable in arrayName)

The objectType represents the type of objects stored in an array, such as NSString or NSNumber. The *variable is any arbitrarily named variable you want to use. The arrayName is the actual array. Suppose you had an array like this:

NSString *object1 = @"Hello";
NSString *object2 = @"world!";
NSString *object3 = @"Good-bye";
NSArray *myArray = [NSArray arrayWithObjects: object1, object2, object3, nil];

To retrieve every item out of that array using fast enumeration, you could use a for loop like this:

for (NSString *randomVariable in myArray)
    {

NSLog (@"Array element = %@", randomVariable);
    }

To see how fast enumeration works, follow these steps:

If you have stored different types of data in an array, then you can access each item in your array using a for loop that starts at 0 and runs for each item stored in the array using the count method:

int i;
for (i = 0; i < [arrayName count]; i++)
{
     NSLog (@"Element %i = %@", i, [arrayName objectAtIndex: i]);
}

This for loop runs from 0 to the total number of items stored in the array. If you had three items stored in the array, the for loop would run five times (from 0 to 2).

To see how to retrieve data from an array using an ordinary for loop, follow these steps:

When you declare an array, you have to declare it as either an NSArray or NSMutableArray. If you declare an array as an NSArray, you can store data in it once, but never again. If you want your program to be able to store and change data in an array while your program runs, you need to declare your array as an NSMutableArray like this:

NSMutableArray *arrayName;

To add data to an NSMutableArray, you need to define the NSMutableArray to use, use the addObject method, and specify the data to add:

[arrayName addObject: newObject];

Suppose you had the following NSMutableArray and filled it with data like this:

NSString *object1 = @"Hello";
NSString *object2 = @"world!";
NSString *object3 = @"Good-bye";
NSMutableArray *myArray;
myArray= [NSMutableArray arrayWithObjects: object1, object2, object3, nil];

You could add data to this array by using code like this:

[myArray addObject: @"New item"];

This would add the object @"New item" at the end of the array named myArray. To see how the addObject method works, follow these steps:

The first time the for loop runs, it prints all three items in the array (Hello, world!, and Good-bye). The second time the for loops runs, it prints four items stored in the array (Hello, world!, Good-bye, and New item). The addObject method always adds the new item at the end of the array.

The addObject method is fine when you just want to store an item at the end of the array. However, what if you want to store an item in a specific part of an array, such as the beginning or somewhere in the middle? In that case, you have to use the insertObject method, which looks like this:

[arrayName insertObject: newObject atIndex: index];

The main difference between the addObject method and the insertObject method is that when you use the insertObject method, you must also specify the index position where you want to add the new item. If you wanted to insert a new item as the second item in the array, which would be index position 1, you would do so like this:

[arrayName insertObject: newObject atIndex: 1];
[myArray addObject: @"New item"];

This would add the object @"New item" at the end of the array named myArray. To see how the addObject method works, follow these steps:

Just remember that when you specify an index position for inserting an item into an array, that index position must be available. So, for example, if you have an array that consists of three items, which would correspond to index positions 0, 1, and 2, and you try to insert a new item at any index position that's 3 or higher, your program won't work.

Just as you can add and insert new items into an array, you can delete items from an array. When you delete an item, you must specify the index position of the item that you want to delete.

There are actually several methods you can use to delete an item from an array:

[arrayName removeLastObject];

[arrayName removeObjectAtIndex: index];

[arrayName removeObjectAtIndex: 1];

[arrayName removeAllObjects];

[arrayName removeObject: object];

[arrayName removeObject: @"Hello"];

Arrays let you store multiple chunks of data in a single variable. To create an array, you have to create a pointer to an array based on the NSArray or NSMutableArray class. If you just want to store data in an array, use the NSArray class. If you want your program to be able to add data to or delete data from an array while your program is running, use the NSMutableArray class.

Arrays can store different types of data or the same type of data. If you store the same type of data in an array, you can use fast enumeration to access every item in your array. If you store different types of data in an array, you need to use a traditional for loop to retrieve each item in the array.

You can add an item to an NSMutableArray at the end of that array or at a specific index position. You can also delete data from an array in several ways: delete data from a specific position in the array (either from the end of the array or at a specific index position), delete one or more instances of data stored in the array, or delete all items from an array. Arrays are just one way to store multiple, related chunks of data in a single variable.