NSMutableDictionary上的setObject：forKey：是否分配？

Question

Say I have the following:

NSMutableDictionary * dict = [[NSMutableDictionary alloc] init];

Now, when I do

[dict setObject:object forKey:key];

Is a new NSMutableDictionary or NSDictionary allocated, and its values simply added to the NSMutableDictionary , sort of like doing a concat with a String in Java? Or is it that a new key value pair is simply inserted?

Basically, what I am asking is

Say I do this :

@implementation ....

+(void) initialize 
{
    NSMutableDictionary * dict = [[NSMutableDictionary alloc] init];
}

and then do : - (void) addValue { [dict setObject:object forKey:key]; }

Will that be worse or the same as doing :

- (void) addValue
{
    NSDictionary dict = @[key:object]; 
}    
or 

+ (void) initialize
{
    NSDictionary * dict = @[key:object]; 
}

I do understand that +initialize is called only once. What if, in addition, this class was to only be called only once?

Answer 1

As you say you come from Java, both languages have frameworks/libraries with immutable (constant) and mutable (modifiable) data structures so the concepts should be familiar to you. You mention dictionaries and strings, so roughly the correspondence is:

• Immutable strings: NSString (Cocoa), String (Java)
• Mutable string: NSMutableString (Cocoa), StringBuffer (Java)
• Mutable dictionary/map: NSMutableDictionary (Cocoa), HashMap (Java)

HTH

Answer 2

To answer your title question, no, setObject does not allocate an NSMutableDictionary. Same goes for NSMutableArray and addObject. To understand why, remember that Objective-C sets an object to nil when an object is defined without being allocated. Messages sent to nil objects result in nil, which is a very cool thing and can be used to great effect.

The other question I think you are asking is about when to allocate the NSMutableDictionary (or any object that requires allocation). The usual way is with lazy instantiation via custom getters. If you are absolutely sure that you'll be using the object it's ok to put it an init method (as in your last example).

To see how to use lazy instantiation via a custom getter, create a single view application in Xcode (ie, File->New project->Single View Application, etc) open the ViewController.m file, and start with this property (in the interface):

@property (nonatomic, strong) NSMutableDictionary *mutableDictionary;

Here's your custom getter (in the implementation):

- (NSMutableDictionary *)mutableDictionary
{
    if(!_mutableDictionary) {
        _mutableDictionary = [[NSMutableDictionary alloc] init];
    }
    return _mutableDictionary;
}

With that in place, the first time you have a

[mutableDictionary setObject:@"myValue" forKey:@"myKey"]

the getter function will run the if block to allocate it for you. Every subsequent setObject will simply return the existing mutable dictionary.

Answer 3

No, adding objects to a dictionary does not cause memory allocation. The dictionary keeps a strong reference to any objects you add, but those objects are not copied or re-allocated.

Allocating a mutable dictionary and then adding objects to it differs from creating a fixed non-mutable dictionary only in that you get a mutable dictionary. That might allocate a very tiny bit more memory (depending on whether NSMutableDictionary needs more memory than NSDictionary ). But unless you're really, really up against the wall, memory-wise, it's not worth considering.

Also note that while +initialize is only called once, it's a class method and not an instance method. If your dictionary is an instance property, you can't create it there.