foundation总结

NSXXX来源：

Foundation 框架中的类, 使用 NS 这个前缀,此前缀是在 OC 语言用作 NeXTSTEP 操作系统的编程语言时首度确定的, Foundation 框架可谓是 OC 应用程序的基础.
还有个与 Foundation 框架 相伴的框架, 叫做 CoreFoundation ,虽然从技术上讲, CoreFoundation 框架不是 OC 框架, 但是它却是编写 OC 应用程序时所应熟悉的重要框架,
Foundation 框架中的许多功能, 都可以在此框架中找到对应的 C 语言 API, CoreFoundation 框架不仅与 Foundation 名字相似, 而且还有更为紧致的联系, 有个功能叫做 '无缝桥接', 可以把 CoreFoundation 中的 C语言 数据结构 平滑转换为 Foundation 中的 OC 对象, 也可以反向装换.? 比方说, Foundation 框架中的字符串是 NSString, 而它可以转换为 CoreFoundation 里面与之等效的 CFString 对象, 无缝桥接 技术是用某些相当复杂的代码实现出来的, 这些代码可以使得运行期系统把 CoreFoundation 框架中的对象视为普通的 OC 对象

NSArray:

放任何OC类的对象，不允许放基本数据类型，数组里面是id指针，id指针只能指向OC类的对象

1.创建方法：(5)

      NSArray *a = [NSArray array]; //调用工厂方法来初始化，空数组，没有任何意义
    NSArray *a1 = [NSArray arrayWithObject:@"one"]; //只有一个元素的数组，意义不大，可以用一个对象就可以
    NSArray *a2 = [NSArray arrayWithObjects:@"one", @"tow",@"three",nil]; //可以有多个元素，nil不可以丢，标志数组元素结束，就如/0一样
    NSArray *a3 = @[@"one",@"tow",@"three"]; //优化后的方法，最常用
    NSArray *a4 = [NSArray arrayWithArray:a3]; //生成副本

2.数组的属性：

array.count  //求数组元素个数 

3.根据下标取数组值：（单个）

NSString *str = [a4 objectAtIndex:2];//求数组指定下标对应的元素值   优化后可以用C中数组表示NSLog(@"%@", a4[2]);（越界就会导致程序崩溃）
    str = [a4 lastObject];  =》 str = a4 [ a4. count -1 ] ;  //取最后一个元素
    str = [a4 firstObject]; =》 str = [a4 objectAtIndex:0]; //取第一个元素

4.根据元素值求下标：

NSUInteger index = [a4 indexOfObject:@"three"];  //越界后就是一个无比大的值

防止越界：
    if (index >= a4[a4.count - 1]) {
             NSLog(@“元素不存在”);
         }
    else{
            NSLog(@"%lu", index);
        }

5.数组的遍历：(显示，满足条件输出。。。。)

    NSLog(@"%@",array6);  //直接输出

    //面向过程（？还是对象）的循环，只用于遍历
    for (NSString *s in array6) {
     NSLog(@"%@", s);
    }

    //满足条件输出
    NSArray *array6 = @[@"one",@"tow",@"three",@"one"];
        for (NSString *str in array6) {
          if ([str isEqualTo:@"one"] == YES) {
            NSLog(@"%@", str);
             }
     }

6.数组排序三部曲：

1、创建数组：
    NSArray *array = @[i1, i2, i3, i4, i5];
2、写一个方法：实例方法
  //格式,排序规则(声明并实现)
  -(NSComparisonResult) compareInterger:(TRInterger *)other{    //枚举：NSComparisonResult，里面有3个参数
    if ( self.interger > other.interger ) {
        return NSOrderedAscending;  //升序
    }
    else if (  self.interger <  other.interger ){
        return NSOrderedDescending;  //降序
    }
    else{
        return NSOrderedSame;  //相等
    }
}
3、调用： //升序与降序完全取决于规则
  NSArray *sorted = [array sortedArrayUsingSelector:@selector(compareInterger:)];


拼音排序：
(补充)
-(NSComparisonResult)compareName:(TRStudent *)other{
    return [self.pinYin compare:other.pinYin];  // compare:调用方法
}


//转为拼音
        NSMutableString *str = [NSMutableString stringWithString:@"计算机语言"];
        if (CFStringTransform((__bridge CFMutableStringRef)str, 0, kCFStringTransformMandarinLatin, NO))
        {
            NSLog(@"%@", str);
        }
        if (CFStringTransform((__bridge CFMutableStringRef)str, 0, kCFStringTransformStripDiacritics, NO))
        {
            NSLog(@"%@", str);
        }

7.副本当中的数组元素，深浅拷贝生成方法：采纳协议

NSArray *copid = [[NSArray alloc] initWithArray:stu copyItems:NO]; //NO表示是引用计数拷贝   //YES表示深拷贝

---

NSMutableArray:

可变数组，是NSArray的子类

1.创建：（堆上）

    NSMutableArray *array1 =[NSMutableArray array];
    NSMutableArray *array2 = [NSMutableArray arrayWithCapacity:100]; //预估值
    NSMutableArray *array3 = @[@"one", @"tow"]; //退化为NSArray
    NSMutableArray *array4 = [NSMutableArray arrayWithObjects: @"one", @"tow", @"three",nil]; //最常用，不可少nil

2.添加（元素）方法 ：

    [array4 addObject:@"six"]; //末尾添加
    [array4 insertObject:@"fine" atIndex:2]; //指定下标处添加

3.修改（元素）方法：

    [array4 replaceObjectAtIndex:0 withObject:@"NO"]; //指定下标修改
批量修改：
     NSArray *replace = @[@"five", @"six", @"seven"];
    [array4 replaceObjectsInRange:NSMakeRange(1, 2) withObjectsFromArray:replace];

4.删除：

    [array4 removeLastObject]; //删除最后一个元素
    [array4 removeObjectAtIndex:0]; //删除下标元素
    [array4 removeObject:@"six"]; //删除元素
    [array4 removeObjectsInRange:NSMakeRange(0, 2)]; //指定范围删除
    NSArray *del = @[@"five", @"three"];
    [array4 removeObjectsInArray:del]; //删除不连续元素
    [array4 removeAllObjects]; //清空数组

5.每日一练：

TRStudent *stu1 = [[TRStudent alloc] initWithName:@"张三" andAge:18];
TRStudent *stu2 = [[TRStudent alloc] initWithName:@"李四" andAge:20];
TRStudent *stu3 = [[TRStudent alloc] initWithName:@"王五" andAge:19];
TRStudent *stu4 = [[TRStudent alloc] initWithName:@"六" andAge:2];
TRStudent *stu5 = [[TRStudent alloc] initWithName:@"三" andAge:1];
TRStudent *stu6 = [[TRStudent alloc] initWithName:@"四" andAge:0];
TRStudent *stu7 = [[TRStudent alloc] initWithName:@"五" andAge:9];
TRStudent *stu8 = [[TRStudent alloc] initWithName:@"六" andAge:21];
NSArray *class1 = @[stu1, stu2];
NSArray *class2 = @[stu3, stu4];
NSArray *class3 = @[stu5, stu6];
NSArray *class4 = @[stu7, stu8];
NSArray *college1 = @[class1 ,class2];
NSArray *college2 = @[class3, class4];
NSArray *school = @[college1, college2];
//不能一次遍历
for (NSArray *college in school) {
     for ( NSArray *class in college) {
         for (TRStudent *stu in class) {
            //if(stu.age >=20)
            NSLog(@"%@", stu);
          }
      }
}

//数组遍历过程中 删除元素 会有元素遍历不到(丢元素，因为括号里面只执行了一次)
    NSMutableArray *mArray = [@[@1,@2,@3,@4,@5,@6,@7,@8,@9,@10] mutableCopy];
    for (NSInteger i = 0; i < mArray.count; i++) {
        static int index = 0;
        NSLog(@"------ %d",++index);
        [mArray removeObjectAtIndex:i];
    }
    NSLog(@"mArray = %@",mArray);

---

NSDictionary

由键值对组成，关键字不允许重复，值可以重复

1.创建字典（4种）

    1、NSDictionary *dic1 = [NSDictionary dictionaryWithObjectsAndKeys:@"one",@"1"/*先写值，后写关键字*/,@"two",@"2", nil];//创建字典的标准方法
    2、NSDictionary *dic2 = @{@"1":@"one",@"2":@"two"};//优化方法，最常用
    3、NSDictionary *dic4 = [NSDictionary dictionaryWithDictionary:dic3];//创建字典的副本
    4、NSArray *a1 = @[@"one",@"two",@"three"];
        NSArray *a2 = @[@"1",@"2",@"3"];
        NSDictionary *dic3 = [NSDictionary dictionaryWithObjects:a1 forKeys:a2];//将数组转换成字典，两个数组的关键字和值必须对应

2.将字典中的所有值转换成数组的方法

 //获取字典中的所有值的方法,即将字典转换成数组的方法
        a1 = [dic3 allValues];
        NSLog(@"%@",a1);

3.将字典中的所有关键字转换成数组

//获取字典中的所有值的方法,即将字典转换成数组的方法
        a1 = [dic3 allKey];

4.通过关键字找到对应的值（3种）

1、//根据一个关键字查找一个值
        NSString *str = [dic3 objectForKey:@"1"];
2、 str = dic3[@"1"];//优化后的方法，最常用，类似数组
3、 //根据多个关键字找多个值
        NSArray *key1 = @[@"1",@"4"];
        NSArray *object1 = [dic3 objectsForKeys:key1 notFoundMarker:@"无对应值"];

5.求键值对个数的方法

NSLog(@"%lu",dic3.count);//数组，集合，字典，元素个数都是count

6.通过值找到对应的关键字

NSArray *key2 = [dic3 allKeysForObject:@"two"];//把two的所有关键字找出来

7.对字典中的值进行排序

        NSArray *key3 = [dic3 keysSortedByValueUsingSelector:@selector(compare:)];//进行排序
//自定义排序;
//根据年龄排序
        TRStudent *stu1 = [[TRStudent alloc]initWithName:@"张三" andAge:18];
        TRStudent *stu2 = [[TRStudent alloc]initWithName:@"张四" andAge:29];
        TRStudent *stu3 = [[TRStudent alloc]initWithName:@"张五" andAge:20];
        NSDictionary *stu = @{@"1":stu1,@"2":stu2,@"3":stu3};
        NSArray *sortedAge = [stu keysSortedByValueUsingSelector:@selector(compareAge:)];
        for (NSString *key in sortedAge){
            NSLog(@"%@ = %@",key,stu[key]);
        }

-(NSComparisonResult)compareAge:(TRStudent *)other{
    NSNumber *selfAge = [NSNumber numberWithInt:self.age];
    NSNumber *otherAge = [NSNumber numberWithInt:self.age];
    return [selfAge compare:otherAge];
}

8.遍历（3种）

NSEnumerator *e = [dic3 objectEnumerator];//枚举器值遍历
        while (str = [e nextObject]){
            NSLog(@"%@",str);
        }
        e = [dic3 keyEnumerator];//枚举器关键字遍历
        while (str = [e nextObject]) {
            NSLog(@"%@",str);
        }
        for (NSString *s in dic3){//只遍历关键字,不遍历值；快速遍历
            NSLog(@"%@ = %@",s,dic3[s]);
        }
      ```  
######9.字典的文件读写

//字典的文件读写
[dic3 writeToFile:@"/Users/ios-33/Desktop/代码/第一阶段代码/Foundation/day23-8:30/day23-01字典/day23.rtf" atomically:YES];//写进文件

    NSDictionary *dic5 = [NSDictionary dictionaryWithContentsOfFile:@"/Users/ios-33/Desktop/代码/第一阶段代码/Foundation/day23-8:30/day23-01字典/day23.rtf"];//读取文件

-----

####NSMutableDictionary         
可变字典，是不可变字典的子类
######1.创建方法（3种）

1、NSMutableDictionary dict1 = [NSMutableDictionary dictionary];//空字典，有意义，可以添加键值对
2、NSMutableDictionary dict2 = [NSMutableDictionary dictionaryWithCapacity:100];//预估值创建（如果超过预估值的话创建效率就会慢）
3、NSMutableDictionary *dict3 = [NSMutableDictionary dictionaryWithObjectsAndKeys:@"one",@"1",@"two",@"2",@"three",@"3", nil];//存储在堆上；标准方法

######2.添加方法（2种）

1、[dict3 setValue:@"four" forKey:@"4"];
2、NSDictionary *added = @{@"5":@"five",@"6":@"six",@"7":@"seven"};
[dict3 addEntriesFromDictionary:added];//添加多个键值对的方法

######3.覆盖方法

NSDictionary dict5 = @{@"1":@"one",@"2":@"two",@"3":@"three"};
// NSMutableDictionary dict6 = [NSMutableDictionary dictionaryWithObjectsAndKeys:@"aaa",@"1",@"bbb",@"2",@"ccc",@"3", nil];
// [dict6 setDictionary:dict5];//dict5覆盖了dict6

######4.删除方法（3种）

1、[dict3 removeObjectForKey:@"1"];//删除指定关键字对应的键值对
2、NSArray *del = @[@"3",@"5"];//批量删除指定关键字对应的键值对
//[dict3 removeObjectsForKeys:del];
3、 [dict3 removeAllObjects];//清空字典

----

####NSNumber:
（数组里面要放的是OC类的对象）（OC不允许存放基本数据类型的数据）
用于将基本数据类型的数据或变量封装成OC的类
>封装方法：numberWith...
>拆封方法： …Value (任何类都是可以拆的)

double e = 2.68;
NSNumber *i = [NSNumber numberWithDouble（Int Char ……）:e]; //封装基本数据类型
e = [i doubleValue]; 拆封，将O-C类的对象还原为基本数据类型的数据
NSLog(@"%lg",e);
NSLog(@"%@",i);

----

####NSValue
是NSNumber的父类：
进一步的简化NSnumber,主要用于结构体的封装,当然它也可以封装基本类型，就是比较麻烦（是需要取地址的）

typedef struct {
int x;
int y;
}TRPoint;

TRPoint point; //不要用，用就要再堆上分配空间
point.x = 10;
point.y = 20;
NSValue *value = [NSValue valueWithBytes:&point objCType:@encode(TRPoint)];
NSLog(@"%@", value);
TRPoint point1;
[value getValue:&point1];
NSLog(@"%d ,%d",point.x, point.y);

----

####NSSet: 集合
集合：无序，没有重复元素的数组，（元素相同只保留一个）
######1.创建：（3种）

NSSet set1 = [NSSet setWithObjects:@"one",@"tow",@"three",@"one",@"tow", nil]; //标准创建方法
NSSet set2 = [NSSet setWithSet:set1]; // 副本创建
NSArray array = @[@"six",@"six"];
NSSet set3 = [NSSet setWithArray:array]; //用数组来创建元素，也会过滤重复元素

######2.自定义类防止重复：

NSSet *set1 = [NSSet setWithObjects:stu1, stu2 ,stu3 ,stu4, nil]; //自定义类的对象,不会过滤重复元素，需要在自定义类中冲重写粗滤与细滤方法 //初始化的时候就调用过滤方法

过滤方法重写：
//过滤重复元素 （格式）
-(NSUInteger)hash{ //粗滤
return self.age; //数值型数据不同，认为2个对象就是不同的 //无数值型属性的时候return YES; 不会调用此方法
}
-(BOOL)isEqual:(id)object{ //细滤 ，仅在粗滤过滤相同时才调用
if (self == object) {
return YES; //YES表示重复
}
if ([object isMemberOfClass:[TRStudent class]] == YES) { //TRStudent表示类，不同类就要改写，也可以改为 [self class] 就不要该了，直接当格式使
TRStudent *s = object;
if ([self.name isEqualToString:s.name]==YES && self.age == s.age) {
return YES;
}
}
return NO; //表示没有重复
}

NSObject里面的过滤方法：
-(NSUInteger)hash{
return YES;
}
-(BOOL)isEqual:(id)object{
if (self == object) {
return YES; //YES表示重复
}
}

######3.判断方法：

判断集合中是否有指定元素：
[set1 containsObject:@"tow"] //返回布尔值
判断2个集合是否相等：
[set1 isEqualToSet:set2] //返回布尔值
判断子集：
[set4 isSubsetOfSet:set1] //返回布尔值

######4.集合与数组的相互转换：

集合转换为数组：
NSArray array1 = [set1 allObjects]
数组转换为集合：
NSSet set3 = [NSSet setWithArray:array];

######5.遍历集合：(4种)

NSLog(@"%@", set); //准遍历，无条件遍历
//面向过程的循环：集合遍历要将它转为数组
NSArray a = [set1 allObjects];
for (int i=0; i<a.count; i++) {
// NSLog(@"%@", set1[i]);
//NSLog(@"%@", [set1 objectAtIndex:i]);
NSLog(@"%@", a[i]);
}
//面向对象的循环，遍历数组
for (NSString str in set1) {
if ([str isEqualToString:@"one"] == YES) {
NSLog(@"%@",str);
}
}

//枚举器遍历
NSEnumerator e = [set1 objectEnumerator]; //objectEnumerator NSSet类中的方法
NSString str;
while (str = [e nextObject]) { // nextObject //获取元素给str NSEnumerator类中的方法
NSLog(@"%@", str);
}

-----

####NSMutableSet:
可变集合，NSSet的子集
######1.创建：(3)

NSMutableSet set1 = [NSMutableSet set]; //工厂方法，空集合，有意义
NSMutableSet set2 = [NSMutableSet setWithCapacity:100]; //预估值，在没有到100的时候扩充效率比较高
NSMutableSet *set3 = [NSMutableSet setWithObjects:@"one", @"tow",@"three", nil];//是重写了setWithObjects:，所以是在堆上面创建对象,// 此方法也调用粗滤与细滤过滤重复元素

######2.添加元素：(2)（在添加的时候都会调用粗滤与细滤过滤重复元素）

[set3 addObject:@"one"];// 添加一个元素
NSArray *added = @[@"five", @"six"]; [set3 addObjectsFromArray:added]; //添加多个元素，要用数组来添加
NSString提供了过滤方法

######3.删除方法：(2)

[set3 removeObject: @"one"]; //删除指定元素
[set3 removeAllObjects]; //删除全部元素

######4.运算方法：

交集：
[set2 intersectSet:set3]; //结果被放到了set2
并集：
[set2 unionSet:set3]; //结果被放到了set2
删除交集部分：
[set2 minusSet:set3]; //结果被放到了set2

-----

####NSString: 
对象放于代码区(用@创建的都放)
######1.创建对象并初始化或赋值（3种）

1.NSString str = [[NSString alloc]init]; //空字符串,没有意义，NSString创建的是常量，保存在代码区
2.NSString str1 = @“Hello World"; NSString str2 = @“Hello World"; //@自动生成一个对象，是一个对象运算符，同一对象只会保留一份
3.NSString str = [NSString stringWithFormat:@"%@ World %d",@"Hello", 10]; //stringWithFormat：此时就不是同一个对象了, 人为%d的对象不确定，所以就不会分配为同地址

######2.字符串的截取：

截取头：NSString str = [str7 substringToIndex:3]; //截取了从0到下标3结束, 截取前面多少个
截取尾：NSString str = [str7 substringFromIndex:9]; //截取了下标9到最后字符， 去掉前面多少个
截取中断：NSString *str = [str7 substringWithRange:NSMakeRange(4, 4)]; //NSMakeRange(4, 4)带参宏，截取区间从下标4开始截取4位

######3.拼接方法：

NSString str = [[NSString alloc]initWithFormat:@"%@ %@",str1, str2 ]; //初始化拼接
NSString str = [str1 stringByAppendingString: str2]; //追加拼接
NSString *str = [str1 stringByAppendingFormat:@"%@ %d %@”, str2, 123, str3]; //格式化拼接，插入化拼接可以将数值转为字符串再拼接

######4.替换：(会生成另一个字符串)

NSString *str = [str1 stringByReplacingCharactersInRange:NSMakeRange(4, 10) withString:@" tedu"];

######5.判断：

[str1 isEqualToString:user]

######6.用占位符%@输出自定义类的对象

重写方法：description
//描述
-(NSString )description
{
NSString str = [NSString stringWithFormat:@"姓名:%@,年龄:%d,性别:%@,家庭住址:%@", self.name, self.age,self.gender?@"男":@"女", self.address];
return str;
}

----

####NSMutableString：
可变字符串，是NSString类的子类，对象放于堆区，（增加了以下3种方法）
######1.创建方法：

1、NSMutableString str = [[NSMutableString alloc] init]; //添加字符的时候会导致低效率
2、NSMutableString str = [NSMutableString stringWithCapacity:100]; //预估计，不是上限，突破100就会导致低效率（创建空间与增加空间需要时间的，alloc 与realloc 都是需要时间的）
3、NSMutableString str = @"abc"; //str3会退化为不可变字符串，不能这样初始化可变字符串（不能算创建可变字符串）
4、NSMutableString str = [NSMutableString stringWithString:@"string"]; //创建可变字符串的对象的同时进行初始化
5、NSMutableString *str = [NSMutableString stringWithFormat:@"age:%d", 6]; //创建可变字符串对象的同时进行格式化初始

######2.添加（字符）方法：

[str2 appendString:@"The word, string"]; //在末尾添加字符串
[str6 appendFormat:@"has %lu characters",(unsigned long)str6.length]; //有format是支持把数字转为字符的

######3.删除（字符）方法：

[str7 deleteCharactersInRange:NSMakeRange(14, 10)]; //删除指定区域内字符串（数的麻烦）
[str7 deleteCharactersInRange:[str7 rangeOfString:@" OBjective-C”]]; //只会删除一个，删完要用循环 ，[str7 rangeOfString:@" OBjective-C”] //确定子串的范围等同于NSMakeRange(14, 10)

######4.找位置：
（用开头字符与字符串长度来确定位置）

自数：NSMakeRange(4, 10) 带参宏
不用数：[str7 rangeOfString:@" OBjective-C”] ，确定字符串位置

######5.替换（字符）方法： （在原来字符串上替换）

[str8 replaceCharactersInRange:[str8 rangeOfString: @"a"] withString:@"another"]; //将a替换为another

####注：可变类的对象创建在堆区（方便扩展）， 不可变类的对象创建在代码区

------

####Block                               
一种新的数据类型，用于定义变量
Block类型的变量中存储的数据是**一段程序代码**

######1.语法

void/返回值类型/(^myBlock/名字/)(void/形参/) = ^void(void)/与前面一一对应/{
NSLog(@"Block被执行了")
double (^myBlock1)(int,int/可以直接只写数据类型/) = ^double(int a,int b/需要写上形参名/){
return a+b;
};;
};
（左右相等）
typedef void(^BlockType)(void);//定义了一个Block的数据类型
typedef double(^myBlock2)(int,int);

######2.Block与全局变量

//Block与全局变量
myBlock2 b3 = ^double(int a,int b){
a *= g_i;//全局变量可以被访问
g_i = 20;//全局变量可以被赋值
return a+b;
};
NSLog(@"%lg",b3(2,3));
NSLog(@"%d",g_i);

######3.Block与局部变量

//Block与局部变量
int i2 = 30;
__block int i3 = 50;
BlockType b4 = ^void(void){
NSLog(@"%d",i2);//局部变量可以在Block中被访问
// i2= 40;//局部变量不能在Block中被赋值
i3 = 60;//加上关键字__block后，局部变量可以在Block中被赋值
};
b4();
NSLog(@"%d",i3);

######4.Block在自定义类中的使用

//Block在自定义类中的使用
TRMyClass *myC = [[TRMyClass alloc]init];
[myC method];

    [myC method:^void(void){
        NSLog(@"无话可说");
    }];
    
    [myC method:^void(void){
        NSLog(@"有话说");
    }];
    
    [myC method2:^double(int a,int b){
        return a+b;
    }];
    [myC method2:^double(int a,int b){
        return a*b;
    }];
    
    [myC method3:^double(int a,int b){//既传算法又传数据的Block
        return a+b;
    }withX:10 andY:20];
    [myC getBlock]();
    
    myC.b = ^void(void){
        NSLog(@"Block做类的属性");
    };
    myC.b();

######5.Block与数组

//Block与数组的关系
NSNumber a1 = [NSNumber numberWithInt:10];
NSNumber a2 = [NSNumber numberWithInt:8];
NSNumber a3 = [NSNumber numberWithInt:20];
NSNumber a4 = [NSNumber numberWithInt:2];
NSNumber *a5 = [NSNumber numberWithInt:15];

    NSArray *num = @[a1,a2,a3,a4,a5];
    NSArray *sorted = [num sortedArrayUsingComparator:^NSComparisonResult(id obj1,id obj2){
        return [obj1 compare:obj2];//从小到大排序
    }];
    NSLog(@"%@",sorted);
    
    NSArray *str = @[@"one",@"two",@"three"];
    sorted = [str sortedArrayUsingComparator:^NSComparisonResult(id obj1,id obj2){
        return [obj1 compare:obj2];//按字母的大小顺序排序
    }];
    NSLog(@"%@",sorted);

######6.Block与字典

//Block与字典
NSDictionary dic1 = @{@"1":a1,@"2":a2,@"3":a3,@"4":a4,@"5":a5};
sorted = [dic1 keysSortedByValueUsingComparator:^NSComparisonResult(id obj1 ,id obj2){
return [obj1 compare:obj2];//从小到大排序
}];
for (NSString key in sorted){
NSLog(@"%@ = %@",key,dic1[key]);
}
NSLog(@"---------------");
NSDictionary dic2 = @{@"1":@"one",@"2":@"two",@"3":@"three",@"4":@"four",@"5":@"five"};
sorted = [dic2 keysSortedByValueUsingComparator:^NSComparisonResult(id obj1, id obj2) {
return [obj1 compare:obj2];//按字母的大小顺序排序
}];
for (NSString key in sorted){
NSLog(@"%@ = %@",key,dic2[key]);
}

######7.Block 和 函数指针 的本质区别

    fun();
    //Block 和 函数指针 的本质区别
    myBlock();//所指向的代码是没有名字的

// void (*pf)() = fun;//函数指针,但是指向的代码要有名字
// pf();
NSLog(@"%lg",myBlock1(2,3));

----

>**浅拷贝：**一个强指针，一个弱指针同时指向一个空间，强引用的对象释放后，弱引用跟着指向空指针
>
>**引用计数拷贝：**避免了浅拷贝和深拷贝的缺点，被大量使用
>两个强指针指向同一空间
>
>以上两者是共用同一块空间，优点，节省存储空间
>
>**深拷贝：**
>**最大的特点：**两个指针各自有自己的存储空间
>**优点：**两个指针互不干扰
>**缺点：**耗费的存储空间大
>

#####1. **浅拷贝：**
2个指针同时指向一空间，一个释放了，另一个也被迫释放（强引用+弱引用），节省存储空间(强引用的空间释放了弱引用指针则为空)

TRStudent *s1 = [[TRStudent alloc]init];
__weak TRStudent *s2 = s1 ;

#####2. **引用计数的拷贝：**
2个指针同时指向一空间，一个释放了，另一个不被迫释放（强引用+强引用）

TRStudent s1 = [[TRStudent alloc]init];
TRStudent s2 = s1 ;

以上为同一存储空间

深拷贝：2个不同的存储空间  （面试题）
int *p1 = (int*)malloc(4);
*p1 = 10;
int *p2 = (int *)malloc(4);
*p2 *p1;

#####3. **深拷贝：**
>NSCopyiny协议：
1 自定义类实现深拷贝时，需要采纳 NSCopying 协议  
2 在自定义的.m文件中实现NSCopying协议中的方法 copyWithZone
3 在主函数中，用copy方法实现深拷贝，该方法在函数体中，会自动调用copyWithZone方法
4 copy可以作为property的参数，使属性赋值时得到的是副本（深拷贝）

三部曲：

采纳， 实现函数体（重写）， 调用[b1 copy]得到副本

// 1.在.h文件中采纳:
@interface TRStudent : NSObject

// 2.实现函数体（重写）与工厂方法很像;
不用放入__autirelaesing
alloc不同 ->allocWithZone
带参初始化用self.xxx
-(id)copyWithZone:(NSZone )zone{
TRCicle c = [[TRCicle allocWithZone:zone]initWithRadius:self.radius andOrgin:self.center];
return c;
}
-(id)copy{
….
id obj = [self copyWithZone]; //方法调用
…
return obj;
}

// 3.调用[b1 copy]得到副本:
TRCicle *c2 = [c1 copy];

------

####NSDate:
OC中的日期时间类

NSDate *date = [NSDate date];
NSLog(@"%@", date); //世界标准时间

######1.本地时间

//本地时间是一个格式代码 (2种格式)
NSDate date = [NSDate date];
NSLog(@"%@", localTime()); //调用函数
NSLog(@"%@", [date localTime]); (添加为分类)只是条用方法不一样
NSLog(@"%@", [NSDate localTime]); (添加为分类)
//调用函数
NSDate localTime()
{
NSTimeZone zone = [NSTimeZone systemTimeZone];
NSUInteger integer = [zone secondsFromGMTForDate:[NSDate date]];
NSDate localTime = [[NSDate date] dateByAddingTimeInterval:integer];
return localTime;
}
//添加为分类（ NSDate + TRLoacalTime ）
-(NSDate )localTime
{
return [NSDate localTime];
}
+(NSDate )localTime
{
NSTimeZone zone = [NSTimeZone systemTimeZone];
NSUInteger integer = [zone secondsFromGMTForDate:[NSDate date]];
NSDate localTime = [[NSDate date] dateByAddingTimeInterval:integer];
return localTime;
}

######2.时间间隔（3种）：

NSDate *date2 = [NSDate dateWithTimeIntervalSinceNow:-60]; //从现在时间开始后的前后n秒
NSTimeInterval seconds = [date timeIntervalSince1970]; //
seconds = [time1 timeIntervalSinceDate:time2];

######3.指定格式输出时间：

NSDateFormatter df = [[NSDateFormatter alloc] init];
df.dateFormat = @"yyyy年MM月dd日 HH:mm:ss EEE";
NSString str = [df stringFromDate:[NSDate date]];
NSLog(@"%@", str);

######4.时间对比：

NSDate earlierDate = [time1 earlierDate:time2]; //获取较早的时间
NSDate laterDate = [time1 laterDate:time2]; // 获取较晚的时间
[time2 isEqualToDate:time2] //判断时间是否相同，以纳秒来计算时间的，按时间的创建时间先后来判断

------

####NSObject   
所有自定义类的根类，所有类的父类

提供了类对象的创建方法  包括：alloc、init、new 、dealloc 

[TRDog new];（为转行的人准备，例如：C++语言转 IOS 语言） 相当于 [[TRDog alloc]init];
```

转载于:https://www.cnblogs.com/xulinmei/p/7420077.html