项目中遇到过因为对于json跟NSDictionary概念混淆造成的bug。网上冲浪后也没有很清楚的解释，决定自己查阅资料研究一下，下文重点针对NSDictionary详细了解，基础概念不做详细解释。
1. Json对象和Json字符串的区别
项目中经常将两者概念混淆，简而言之将json结构的数据用引号包括，就是json字符串。例如：
var a = {"name":"tom","sex":"男","age":"24"};//json对象
var b = '{"name":"2323","sex":"afasdf","age":"6262"}';//json字符串
以上a是个json对象，可以用点去访问，例如：a.name，但是b不能。
2. NSDictionary
一直搞不清楚字典NSDictionary到底是什么东西，它的结构是怎样的，它跟json有什么关系，下面就来研究一下。
Hash哈希
NSDictionary（字典）是使用 hash表来实现key和value之间的映射和存储的，要想更清楚的了解字典就免不了对哈希有个清晰的认识。
Hash，一般翻译为哈希或者散列，是将任意长度的输入通过算法(散列算法)变换成固定长度的输出(散列值)。这种转换是一种压缩映射，也就是说不同的输入可能会散列成相同的输出（散列冲突）。可以理解为将任意长度的消息压缩后得到固定长度的消息摘要的一个过程。
Hash算法没有固定的公式，只要符合散列思想的算法都可以称为是hash算法。
若结构中存在和关键字K相等的记录，则必定在f(K)的存储位置上。由此，不需比较便可直接取得所查记录。称这个对应关系f为散列函数（Hash function），按这个事先建立的表为散列表。
hash在字典中的映射使用类似于H(key) = a·key + b，key即为字典的键值（NSString类型），H(key)该key值对应的value在内存中的地址。很明显，这种方式比起遍历提高了访问效率。
所有散列函数都有如下一个基本特性：如果两个散列值是不相同的（根据同一函数），那么这两个散列值的原始输入也是不相同的。这个特性是散列函数具有确定性的结果。但另一方面，散列函数的输入和输出不是一一对应的，如果两个散列值相同，两个输入值很可能是相同的，但不绝对肯定二者一定相等（可能出现哈希碰撞）。输入一些数据计算出散列值，然后部分改变输入值，一个具有强混淆特性的散列函数会产生一个完全不同的散列值。
常用的HASH函数
散列函数能使对一个数据序列的访问过程更加迅速有效，通过散列函数，数据元素将被更快地定位。常用Hash函数有：
1．直接寻址法。取关键字或关键字的某个线性函数值为散列地址。即H(key)=key或H(key) = a·key + b，其中a和b为常数（这种散列函数叫做自身函数）
2．数字分析法。分析一组数据，比如一组员工的出生年月日，这时我们发现出生年月日的前几位数字大体相同，这样的话，出现冲突的几率就会很大，但是我们发现年月日的后几位表示月份和具体日期的数字差别很大，如果用后面的数字来构成散列地址，则冲突的几率会明显降低。因此数字分析法就是找出数字的规律，尽可能利用这些数据来构造冲突几率较低的散列地址。
3．平方取中法。取关键字平方后的中间几位作为散列地址。
4．折叠法。将关键字分割成位数相同的几部分，最后一部分位数可以不同，然后取这几部分的叠加和（去除进位）作为散列地址。
5．随机数法。选择一随机函数，取关键字作为随机函数的种子生成随机值作为散列地址，通常用于关键字长度不同的场合。
6．除留余数法。取关键字被某个不大于散列表表长m的数p除后所得的余数为散列地址。即 H(key) = key MOD p,p<=m。不仅可以对关键字直接取模，也可在折叠、平方取中等运算之后取模。对p的选择很重要，一般取素数或m，若p选的不好，容易产生碰撞。
哈希处理冲突方法
1．开放寻址法；Hi=(H(key) + di) MOD m,i=1,2,…，k(k<=m-1)，其中H(key)为散列函数，m为散列表长，di为增量序列，可有下列三种取法：
1)． di=1,2,3,…，m-1，称线性探测再散列；
2)． di=12,-12,22,-22,32,…，±k2,(k<=m/2)称二次探测再散列；
3)． di=伪随机数序列，称伪随机探测再散列。
2． 再散列法：Hi=RHi(key),i=1,2,…，k RHi均是不同的散列函数，即在同义词产生地址冲突时计算另一个散列函数地址，直到冲突不再发生，这种方法不易产生“聚集”，但增加了计算时间。
3． 链地址法(拉链法)
4． 建立一个公共溢出区
哈希的应用如MD5等SHA-1等这里不做过多讲解。
NSDictionary介绍
我们在使用NSDictionary/NSMutableArray时，通常会使用NSString对象作为key，因为key必须遵循NSCopying协议，见NSMutableArray中的方法：
- (void)setObject:(ObjectType)anObject forKey:(KeyType <NSCopying>)aKey;
而NSString也遵循NSCopyiing协议：
@interface NSString : NSObject <NSCopying, NSMutableCopying, NSSecureCoding>
在NSDictionary/NSMutableArray对象中，aKey对象被copy一份后存入，anObject对象则被强引用。来看一段代码：
NSMutableDictionary *mutaDic = [[NSMutableDictionary alloc] initWithCapacity:0];
{
NSString *aKey = @"akey";
NSObject *aObject = [[NSObject alloc] init];
[mutaDic setObject:aObject forKey:aKey];
}
NSLog(@"dictionary: %@", mutaDic);
打印日志：
dictionary: {
akey = "<NSObject: 0x60400001d3b0>";
}
本来作用域结束后，aKey变量指向的NSString对象（简称aKey对象）和aObject变量指向的NSObject对象（简称aObject对象）应该被自动释放，但是aDictionary变量指向的NSMutableDictionary对象（简称aDictionary对象）持有一份aObject对象的强引用，所以打印日志时，aDictionary对象不为空。
NSDictionary/NSMutable使用hash表来实现key和value之间的映射和存储，所以作为key值的类型必须重写hash和isEqual:两个方法，其中hash方法计算该对象的hash值，hash值决定该对象在hash表中存储的位置，isEqual方法通过hash值来定位对象在hash表中的位置。具体代码如下:
// Teacher.h
@interface Teacher : NSObject<NSCopying>
@property (nonatomic, copy) NSString *name;
@property (nonatomic, assign) NSInteger age;
@end
// Teacher.m
@implementation Teacher
- (id)copyWithZone:(NSZone *)zone
{
Teacher *teacher = [[Teacher allocWithZone:zone] init];
teacher.name = self.name;
teacher.age = self.age;
return teacher;
}
- (BOOL)isEqual:(id)object
{
// 比较hash值是否相等
return [self hash] == [object hash];
}
- (NSUInteger)hash
{
// 调用父类的hash方法，也可以自定义
return [super hash];
}
NSMapTable浅析
NSMapTable继承自NSObject，自iOS6.0开始使用，NSMapTable是可变的。
NSMapTable有两个指定初始化方法和一个便捷初始化方法：
// 指定初始化方法
- (instancetype)initWithKeyOptions:(NSPointerFunctionsOptions)keyOptions valueOptions:(NSPointerFunctionsOptions)valueOptions capacity:(NSUInteger)initialCapacity NS_DESIGNATED_INITIALIZER;
- (instancetype)initWithKeyPointerFunctions:(NSPointerFunctions *)keyFunctions valuePointerFunctions:(NSPointerFunctions *)valueFunctions capacity:(NSUInteger)initialCapacity NS_DESIGNATED_INITIALIZER;
// 便捷初始化方法
+ (NSMapTable<KeyType, ObjectType> *)mapTableWithKeyOptions:(NSPointerFunctionsOptions)keyOptions valueOptions:(NSPointerFunctionsOptions)valueOptions;
初始化方法方法中有两个参数keyOptions和valueOptions，都是NSPointerFunctionsOptions类型，NSPointerFunctionsOptions是一个枚举类型，
typedef NS_OPTIONS(NSUInteger, NSPointerFunctionsOptions) {
// Memory options are mutually exclusive
// default is strong
NSPointerFunctionsStrongMemory API_AVAILABLE(macos(10.5), ios(6.0), watchos(2.0), tvos(9.0)) = (0UL << 0), // use strong write-barrier to backing store; use GC memory on copyIn
#if (TARGET_OS_MAC && !(TARGET_OS_EMBEDDED || TARGET_OS_IPHONE)) || TARGET_OS_WIN32
NSPointerFunctionsZeroingWeakMemory NS_ENUM_DEPRECATED_MAC(10_5, 10_8) = (1UL << 0), // deprecated; uses GC weak read and write barriers, and dangling pointer behavior otherwise
#endif
NSPointerFunctionsOpaqueMemory API_AVAILABLE(macos(10.5), ios(6.0), watchos(2.0), tvos(9.0)) = (2UL << 0),
NSPointerFunctionsMallocMemory API_AVAILABLE(macos(10.5), ios(6.0), watchos(2.0), tvos(9.0)) = (3UL << 0), // free() will be called on removal, calloc on copyIn
NSPointerFunctionsMachVirtualMemory API_AVAILABLE(macos(10.5), ios(6.0), watchos(2.0), tvos(9.0)) = (4UL << 0),
NSPointerFunctionsWeakMemory API_AVAILABLE(macos(10.8), ios(6.0), watchos(2.0), tvos(9.0)) = (5UL << 0), // uses weak read and write barriers appropriate for ARC
// Personalities are mutually exclusive
// default is object. As a special case, 'strong' memory used for Objects will do retain/release under non-GC
NSPointerFunctionsObjectPersonality API_AVAILABLE(macos(10.5), ios(6.0), watchos(2.0), tvos(9.0)) = (0UL << 8), // use -hash and -isEqual, object description
NSPointerFunctionsOpaquePersonality API_AVAILABLE(macos(10.5), ios(6.0), watchos(2.0), tvos(9.0)) = (1UL << 8), // use shifted pointer hash and direct equality
NSPointerFunctionsObjectPointerPersonality API_AVAILABLE(macos(10.5), ios(6.0), watchos(2.0), tvos(9.0)) = (2UL << 8), // use shifted pointer hash and direct equality, object description
NSPointerFunctionsCStringPersonality API_AVAILABLE(macos(10.5), ios(6.0), watchos(2.0), tvos(9.0)) = (3UL << 8), // use a string hash and strcmp, description assumes UTF-8 contents; recommended for UTF-8 (or ASCII, which is a subset) only cstrings
NSPointerFunctionsStructPersonality API_AVAILABLE(macos(10.5), ios(6.0), watchos(2.0), tvos(9.0)) = (4UL << 8), // use a memory hash and memcmp (using size function you must set)
NSPointerFunctionsIntegerPersonality API_AVAILABLE(macos(10.5), ios(6.0), watchos(2.0), tvos(9.0)) = (5UL << 8), // use unshifted value as hash & equality
NSPointerFunctionsCopyIn API_AVAILABLE(macos(10.5), ios(6.0), watchos(2.0), tvos(9.0)) = (1UL << 16), // the memory acquire function will be asked to allocate and copy items on input
};
常用的枚举值及对应的含义如下：
1.NSPointerFunctionsStrongMemory: 强引用存储对象
2.NSPointerFunctionsWeakMemory： 弱引用存储对象
3.NSPointerFunctionsCopyIn：copy存储对象
就是说，如果NSMapTable的初始化方法为：
NSMapTable *aMapTable = [[NSMapTable alloc] initWithKeyOptions:NSPointerFunctionsCopyIn valueOptions:NSPointerFunctionsStrongMemory capacity:0];
或
NSMapTable *aMapTable = [NSMapTable mapTableWithKeyOptions:NSPointerFunctionsCopyIn valueOptions:NSPointerFunctionsStrongMemory];
那么就等同于NSMutableDictionay的初始化方法：
NSMutableDictionary *aDictionary = [[NSMutableDictionary alloc] initWithCapacity:0];
或
NSMutableDictionary *aDictionary = [NSMutableDictionary dictionary];
若初始方法修改为
NSMapTable *aMapTable = [NSMapTable mapTableWithKeyOptions:NSPointerFunctionsWeakMemory valueOptions:NSPointerFunctionsStrongMemory];
即对key值进行弱引用，就可以不用让Teacher类遵循NSCopying协议和重新跟hash有关的两个方法，代码如下：
// Teacher.h
@interface Teacher : NSObject
@property (nonatomic, copy) NSString *name;
@property (nonatomic, assign) NSInteger age;
@end
// Teacher.m
@implementation Teacher
@end
// ViewController.m
Teacher *teacher = [[Teacher alloc] init];
teacher.name = @"teacher";
teacher.age = 30;NSMutableArray *aArray = [[NSMutableArray alloc] initWithCapacity:0];
for (int i = 0; i < 3; i++) {
Student *student = [[Student alloc] init];
student.name = [NSString stringWithFormat:@"student%d", i];
student.age = i;
[aArray addObject:student];
}
NSMapTable *aMapTable = [NSMapTable mapTableWithKeyOptions:NSPointerFunctionsWeakMemory valueOptions:NSPointerFunctionsStrongMemory];
[aMapTable setObject:aArray forKey:teacher];
NSLog(@"%@", aMapTable);
打印日志：
NSMapTable {
[10] <Teacher: 0x604000038a40> -> (
"<Student: 0x60400003c640>",
"<Student: 0x60400003c660>",
"<Student: 0x60400003c620>"
)
}
这样的方法可以快速的将NSObject对象作为key存入到“字典”中。
由于NSDictionary/NSMutableArray会强引用value，使得value的引用计数+1，加入不希望怎么做，可以用NSMapTable来实现。
NSMapTable *aMapTable = [NSMapTable mapTableWithKeyOptions:NSPointerFunctionsStrongMemory valueOptions:NSPointerFunctionsWeakMemory];
{
NSObject *keyObject = [[NSObject alloc] init];
NSObject *valueObject = [[NSObject alloc] init];
[aMapTable setObject:valueObject forKey:keyObject];
NSLog(@"NSMapTable:%@", aMapTable);
}
NSLog(@"NSMapTable:%@", aMapTable);
打印日志：
NSMapTable:NSMapTable {
[6] <NSObject: 0x60c00000c690> -> <NSObject: 0x60c00000c730>
}
NSMapTable:NSMapTable {
}
第一个NSLog打印出了key-value值，等到object对象指向的NSObject对象超出作用域，释放该对象，由于aMapTable弱引用object对象，aMapTable的中的key-value值会被安全的删除，第二个NSLog打印出的值为空。
NSMapTable与NSDictionary/NSMutableDictionary对比
- NSDcitionary有一个可变类型NSMutableDictionary，NSMapTable没有可变类型，它本身就是可变的;
- NSDcitionary/NSMutableDictionary中对于key和value的内存管理方法唯一，即对key进行copy，对value进行强引用，而NSMapTable没有限制；
- NSDcitionary中对key值进行copy，不可改变，通常用字符串作为key值，只是key->object的映射，而NSMapTable的key是可变的对象，既可以实现key->object的映射，又可以实现object->object的映射。
NSMapTable的应用还有实现Block的一对多回调 iOS中如何用Block实现一对多回调本文中不再赘述
NSDictionary内部结构
NSDictionary（字典）是使用 hash表来实现key和value之间的映射和存储的， hash函数设计的好坏影响着数据的查找访问效率。数据在hash表中分布的越均匀，其访问效率越高。而在Objective-C中，通常都是利用NSString 来作为键值，其内部使用的hash函数也是通过使用 NSString对象作为键值来保证数据的各个节点在hash表中均匀分布。
NSDictionary使用NSMapTable实现，NSMapTable同样是一个key－value的容器。
typedef struct {
NSMapTable *table;
NSInteger i;
struct _NSMapNode *j;
} NSMapEnumerator;
上述结构体描述了遍历一个NSMapTable时的一个指针对象，其中包含table对象自身的指针，计数值，和节点指针。
typedef struct {
NSUInteger (*hash)(NSMapTable *table,const void *);
BOOL (*isEqual)(NSMapTable *table,const void *,const void *);
void (*retain)(NSMapTable *table,const void *);
void (*release)(NSMapTable *table,void *);
NSString *(*describe)(NSMapTable *table,const void *);
const void *notAKeyMarker;
} NSMapTableKeyCallBacks;
上述结构体中存放的是几个函数指针，用于计算key的hash值，判断key是否相等，retain，release操作。
typedef struct {
void (*retain)(NSMapTable *table,const void *);
void (*release)(NSMapTable *table,void *);
NSString *(*describe)(NSMapTable *table, const void *);
} NSMapTableValueCallBacks;
上述存放的三个函数指针，定义在对NSMapTable插入一对key－value时，对value对象的操作。
@interface NSMapTable : NSObject {
NSMapTableKeyCallBacks *keyCallBacks;
NSMapTableValueCallBacks *valueCallBacks;
NSUInteger count;
NSUInteger nBuckets;
struct _NSMapNode **buckets;
}
可以看出来NSMapTable是一个哈希＋链表的数据结构，因此在NSMapTable中插入或者删除一对对象时，
寻找的时间是O（1）＋O（m），m最坏时可能为n。
O（1）：为对key进行hash得到bucket的位置
O（m）：遍历该bucket后面冲突的value，通过链表连接起来。
因此NSDictionary中的Key-Value遍历时是无序的，至如按照什么样的顺序，跟hash函数相关。NSMapTable使用NSObject的哈希函数。
- (NSUInteger)hash {
return (NSUInteger)self>>4;
}
上述是NSObject的哈希值的计算方式，简单通过移位实现。右移4位，左边补0。
字典内部结构转自NSDictionary底层实现原理
总结
通过以上，大致了解到苹果对于NSDictionary的设计有着自己的想法，内部其实做了很多事情，所以iOS项目中对于json字符串（注意：是json字符串）的转换写法会比较繁琐。
//JSON字符串转NSDictionary
+ (NSDictionary *)dictionaryWithJsonString:(NSString *)jsonString {
if (jsonString == nil) {
return nil;
}
NSData *jsonData = [jsonString dataUsingEncoding:NSUTF8StringEncoding];
NSError *err;
NSDictionary *dic = [NSJSONSerialization JSONObjectWithData:jsonData
options:NSJSONReadingMutableContainers
error:&err];
if(err) {
NSLog(@"json解析失败：%@",err);
return nil;
}
return dic;
}
并且对于接收到的json对象会自动转成字典NSDictionary类型，所以需要也不能将NSDictionary直接简单的[NSString stringWithFormat:@"%@",dictionary]这种方式去转。
NSDictionary装的数据类型鱼龙混杂，有可能是NSDate，NSNumber，NSValue等Objective-C对象，而[NSJSONSerialization dataWithJSONObject:options:error:]这个方法是不能解析这些对象的，如果有这些对象，则会导致crash。所以我们应该在调用NSJSONSerialization之前加一步，将所有数据处理成NSString，代码如下：
//NSDictionary转JSON字符串
+ (NSString *)jsonStringFromDic:(NSDictionary *)dic {
NSError *error = nil;
NSData *jsonData = nil;
if (!dic) {
return nil;
}
NSMutableDictionary *dict = [NSMutableDictionary dictionary];
[self enumerateKeysAndObjectsUsingBlock:^(id _Nonnull key, id _Nonnull obj, BOOL * _Nonnull stop) {
NSString *keyString = nil;
NSString *valueString = nil;
if ([key isKindOfClass:[NSString class]]) {
keyString = key;
}else{
keyString = [NSString stringWithFormat:@"%@",key];
}
if ([obj isKindOfClass:[NSString class]]) {
valueString = obj;
}else{
valueString = [NSString stringWithFormat:@"%@",obj];
}
[dict setObject:valueString forKey:keyString];
}];
jsonData = [NSJSONSerialization dataWithJSONObject:dict options:NSJSONWritingPrettyPrinted error:&error];
if ([jsonData length] == 0 || error != nil) {
return nil;
}
NSString *jsonString = [[NSString alloc] initWithData:jsonData encoding:NSUTF8StringEncoding];
return jsonString;
}
