NSArray serves as the primary ordered collection type within the Foundation framework, designed specifically to store sequences of Objective-C objects. Unlike primitive C arrays, NSArray instances enforce homogeneity at the object level while maintaining strict ordering of elements.

Core Characteristics

Instances of NSArray exhibit immutability upon initialization. Once constructed, the collection's size and element composition remain fixed throughout its lifecycle. The framework restricts storage to Objective-C objects exclusively; scalar values including int, double, char, or pointer types require boxing into NSNumber or NSValue wrappers prior to insertion.

A critical implementation detail involves the sentinel value nil. The framework interprets nil as a termination marker rather then a valid element. Consequently, attempting to store nil within an array results in undefined behavior or premature truncation of the intended element sequence.

Instantiation Patterns

Foundation provides multiple factory methods for array construction:

// Empty immutable array
NSArray *emptyContainer = [NSArray array];

// Single-element array
NSArray *singleItem = [NSArray arrayWithObject:@"prototype"];

// Variable-argument construction
NSArray *multiElement = [NSArray arrayWithObjects:@"alpha", @"beta", @"gamma", nil];

// Copy construction
NSArray *duplicated = [NSArray arrayWithArray:existingArray];

// External resource loading
NSArray *fromFilesystem = [NSArray arrayWithContentsOfFile:@"/path/to/data.plist"];
NSArray *fromNetwork = [NSArray arrayWithContentsOfURL:resourceURL];

Element Access and Inspection

The class exposes methods for querying collection metadata and retrieving specific elements:

NSArray *inventory = @[@"widget", @"gadget", @"tool", @"instrument"];

NSUInteger itemCount = [inventory count];
id firstEntry = [inventory firstObject];
id finalEntry = [inventory lastObject];
id specificItem = [inventory objectAtIndex:2];

BOOL exists = [inventory containsObject:@"gadget"];
NSUInteger position = [inventory indexOfObject:@"tool"];

NSRange searchScope = NSMakeRange(1, 2);
NSUInteger limitedIndex = [inventory indexOfObject:@"gadget" inRange:searchScope];

Modern Literal Syntax

Objective-C 2.0 introduced concise syntax for array operations:

// Construction using literals
NSArray *cities = @[@"Tokyo", @"Osaka", @"Kyoto"];

// Indexed subscripting instead of method calls
NSString *selectedCity = cities[1];  // Equivalent to objectAtIndex:

Iteration Strategies

Three primary patterns exist for traversing array contents:

NSArray *metrics = @[@"temperature", @"humidity", @"pressure", @"velocity"];

// Traditional indexed iteration
for (NSUInteger i = 0; i < [metrics count]; i++) {
    NSLog(@"Metric %lu: %@", i, metrics[i]);
}

// Fast enumeration protocol
for (NSString *measurement in metrics) {
    NSLog(@"Reading: %@", measurement);
}

// Block-based enumeration with control flags
[metrics enumerateObjectsUsingBlock:^(id obj, NSUInteger idx, BOOL *stop) {
    NSLog(@"Index %lu contains %@", idx, obj);
    if ([obj isEqualToString:@"pressure"]) {
        *stop = YES;  // Terminate iteration early
    }
}];

Serialization Capabilities

Arrays support property list serialization for persistent storage:

NSArray *configuration = @[@"debug_mode", @"verbose_logging", @"cache_enabled"];
NSString *archivePath = [NSHomeDirectory() stringByAppendingPathComponent:@"config.plist"];

BOOL success = [configuration writeToFile:archivePath atomically:YES];

// Retrieval
NSArray *loadedConfig = [NSArray arrayWithContentsOfFile:archivePath];

NSString Integration

Arrays provide bidirectional conversion utilities for string manipulation:

// Joining elements with delimiters
NSArray *pathComponents = @[@"usr", @"local", @"bin"];
NSString *unixPath = [pathComponents componentsJoinedByString:@"/"];

// Parsing delimited strings
NSString *csvData = @"red,green,blue,alpha";
NSArray *colorChannels = [csvData componentsSeparatedByString:@","];

NSMutableArray: Dynamic Collections

NSMutableArray extends NSArray to support mutability, enabling dynamic insertion, deletion, and reordering operations after initialization.

Construction Variants

// Empty mutable container
NSMutableArray *dynamicList = [NSMutableArray array];

// Pre-allocated capacity hint
NSMutableArray *buffer = [[NSMutableArray alloc] initWithCapacity:10];

// Initialization with literal conversion
NSMutableArray *editable = [NSMutableArray arrayWithObjects:@"initial", @"values", nil];

Modification Operations

NSMutableArray *taskQueue = [NSMutableArray arrayWithArray:@[@"task_a", @"task_b"]];

// Appending elements
[taskQueue addObject:@"task_c"];
[taskQueue addObjectsFromArray:@[@"task_d", @"task_e"]];

// Positional insertion
[taskQueue insertObject:@"priority_task" atIndex:0];

// Removal strategies
[taskQueue removeLastObject];
[taskQueue removeObjectAtIndex:1];
[taskQueue removeObject:@"task_a"];
[taskQueue removeObjectsInRange:NSMakeRange(0, 2)];
[taskQueue removeAllObjects];

// Replacement and reordering
[taskQueue replaceObjectAtIndex:0 withObject:@"updated_task"];
[taskQueue exchangeObjectAtIndex:0 withObjectAtIndex:2];

Critical Usage Considerations

A frequent compilation error occurs when attempting to invoke mutating methods on array literals:

// Incorrect: Literals create immutable NSArray instances
NSMutableArray *invalid = @[@"item1", @"item2"];
[invalid addObject:@"item3"];  // Runtime exception: unrecognized selector

// Correct: Explicit mutable construction required
NSMutableArray *valid = [NSMutableArray arrayWithArray:@[@"item1", @"item2"]];
[valid addObject:@"item3"];

The literal syntax @[] always produces NSArray instances regardless of the receiver's declared type. Developers must explicitly invoke NSMutableArray factory methods or use mutableCopy to obtain modifiable collections.