OC：Block语法、Block使用、Block实现数组排序

Block

 

//定义一个求两个数最大值函数

int maxValue (int ,int);

//函数的实现

int maxValue (int a, int b){

    return  a > b ? a : b;

}

//函数指针 （调用可以用 p 或者 maxValue）

        int (* p)(int,int) = maxValue;

        int max =  p(24, 48);

block是一个匿名函数，也是一个函数，只不过没有名字而已。也叫语法块。

把函数名去掉剩余的部分就是函数类型。

对于Block 的定义：

         函数的返回值类型 （^ block 变量名）（参数列表）= ^ 返回值类型（可以省略）（参数列标（形参名不可以省略））{

         }；

 Block 的类型 ：int (^)(int ,int)      //就是把变量名去掉后的部分

         Block 的变量名：

//定义一个无参数无返回值的 block

 //无参数时，小括号不能省去

        void (^ sayHi)() = ^void(){

            NSLog(@"hellow");

        };

        sayHi();

//有参数无返回值的block

        void (^ sayHi1)(int a) = ^ (int a){//block的定义

            NSLog(@"%d",a);

        };

        sayHi1(5);//block的调用

 //定义一个block 实现把数字字符串转化为整数

        int (^ exchangeCagrToInt)(NSString *) = ^ int(NSString * array){

            int n = [array intValue];

            return n;

        };

       //OC对象作为参数使用

        int c = exchangeCagrToInt(@"13");//如果写的是 123ABC 只会打印123  如果是 abc A 之类的就会打印出0，所以以后使用的时候要注意

        NSLog(@"%d",c);

 

 //对比C语言的函数指针

        //对block 进行重命名（是给block变量类型重名名）

        typedef int (^ ValueOfTwo)(int,int);

        //ValueOfTwo 指向 返回值为 int 有两个 int 参数的 bloc 类型的 block

      ValueOfTwo newBlock = ^(int a ,int b){//此时  newBlock 求两个数的和

            return a + b;

        };

//注意

        int number = 20;

        void (^myblock)(int ) = ^(int num){

            NSLog(@"%d",num);

            NSLog(@"%d",number);

            //number 赋新值

            //number = number - num;//这里会报错，因为在block内部不能修改局部变量的值，但是可以访问局部变量的值

        };

        myblock(10);

 __block int number = 20;//这样让block内部可以改变我们定义的局部变量

        void (^myblock)(int ) = ^(int num){

            NSLog(@"%d",num);

            NSLog(@"%d",number);

            //number 赋新值

            number = number - num;//这里不报错，因为在局部变量的值前面加上了修饰符 “__block” 注意是两个下划线哦，但是可以访问局部变量的值

        };

        myblock(10);

//我们称 ^ 为 托字符

//
//  main.m
#import <Foundation/Foundation.h>

//定义一个求两个数最大值函数
int maxValue (int ,int);
//函数的实现
int maxValue (int a, int b){
    return  a > b ? a : b;
}
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // insert code here...
        NSLog(@"Hello, World!");
        //函数指针 （调用可以用 p 或者 maxValue）
        int (* p)(int,int) = maxValue;
        int max =  p(24, 48);
        //Block：匿名函数 也是一种函数  只不过是特殊的函数（匿名函数）
        /*
         对于Block 的定义：
         函数的返回值类型 （^ block 变量名）（参数列表）= ^ 返回值类型（可以省略）（参数列标（形参名不可以省略））{
         }；
         */
//        int (^ maxOfTwo)(int, int) = ^ int(int a,int b){
//            return a > b ? a :b;
//        };
        int (^ maxOfTwo)(int, int) = ^ (int a,int b){
            return a > b ? a :b;
        };
        /*
         Block 的类型 ：int (^)(int ,int)      //就是把变量名去掉后的部分
         Block 的变量名：
         */
        int result = maxOfTwo (12,10);
        NSLog(@"%d",result);
        int (^ mutil)(int ,int) = ^int (int a,int b){
            return a*b;
        };
        int ji = mutil(12 ,4);
        NSLog(@"%d",ji);
        //定义一个无参数无返回值的 block
        //无参数时，小括号不能省去
        void (^ sayHi)() = ^void(){
            NSLog(@"hellow");
        };
        sayHi();
        //有参数无返回值的block
        void (^ sayHi1)(int a) = ^ (int a){
            NSLog(@"%d",a);
        };
        sayHi1(5);
        //block的定义
        void (^ printNum)(int a) = ^ void (int a){
            NSLog(@"%d",a);
        };
        //block的调用
        printNum(10);
        
        
        //定义一个block 实现把数字字符串转化为整数
        int (^ exchangeCagrToInt)(NSString *) = ^ int(NSString * array){
            int n = [array intValue];
            return n;
        };
        int c = exchangeCagrToInt(@"13的是否合格");
        NSLog(@"%d",c);
        //对比C语言的函数指针
        //对block 进行重命名（是给block变量类型重名名）
        typedef int (^ ValueOfTwo)(int,int);
        //ValueOfTwo 指向 返回值为 int 有两个 int 参数的 bloc 类型的 block
        ValueOfTwo newBlock = ^(int a ,int b){
            return a + b;
        };//此时  newBlock 求两个数的和
        int bb = newBlock(10,12);
        NSLog(@"%d",bb);
        ValueOfTwo newMulBlock = ^(int a,int b){
            return a*b;
        };
        int bc = newMulBlock(10,12);
        NSLog(@"%d",bc);
        
        
        //block访问外面定义的局部变量
        __block int number = 20;
        void (^myblock)(int ) = ^(int num){
            NSLog(@"%d",num);
            NSLog(@"%d",number);
            //number 赋新值
            number = number - num;//这里不报错，因为在局部变量的值前面加上了修饰符 “__block” 注意是两个下划线哦，但是可以访问局部变量的值
            
        };
        myblock(10);
    }
    return 0;
}

 // __block 的作用就是在block 块内部使函数的局部变量不仅可以被访问，而且还可以被修改（保护局部变量可以在函数的其他地方被访问和做修改，不影响其他地方的对局部变量的操作）

//在全局的外面定义的变量就是全局变量（我们在main 函数外面声明一个）

int openValue = 12;//在函数内与函数外都可被访问

__block int number = 20;

        void (^myblock)(int ) = ^(int num){

            openValue ++;//全局变量不仅可以直接访问而且还可以直接被修改

            NSLog(@"%d",num);

            NSLog(@"%d",number);

            //number 赋新值

            number = number - num;//这里不报错，因为在局部变量的值前面加上了修饰符 “__block” 注意是两个下划线哦，但是可以访问局部变量的值

            

        };

        myblock(10);

 // __block 的作用就是在block 块内部使函数的局部变量不仅可以被访问，而且还可以被修改（保护局部变量可以在函数的其他地方被访问和做修改，不影响其他地方的对局部变量的操作）
        //练习 ：把数组中的字符串拼接成一个字符串
//        NSArray * stsArr = [NSArray arrayWithObjects:@"Hello",@"Hello",@"39", nil];
        NSArray * strArr = @[@"Hello",@"hhhh",@"39"];
        NSString * (^appendString)(NSArray *) = ^(NSArray * arr){
            NSString * newStr = @"";//这里不能写成：NSString * newStr = nil;
            for (int i = 0 ; i < [arr count]; i++) {
                NSString * append = arr[i];//获取数组中每个字符串对象
                newStr = [newStr stringByAppendingString:append];//拼接功能,注意使用 newStr 去接受
            }
            return newStr;
        };
        NSString * afterAppendSting = appendString(@[@"123",@"456",@"789",@"0"]);
        NSLog(@"%@",afterAppendSting);
    }

//比较两个字符串的大小
        NSString * str1 = @"123";
        NSString * str2 = @"123";
//        BOOL (^ compareStrings)(NSString *,NSString *) = ^(NSString * str01,NSString * str02){
//            NSComparisonResult result = [str01 compare:str02];
//            return result;
//        };//这种写法是错误的

        NSComparisonResult (^ compareStrings)(NSString *,NSString *) = ^(NSString * str01,NSString * str02){
            NSComparisonResult result = [str01 compare:str02];
            return result;
        };
        NSComparisonResult resu = compareStrings(str1,str2);
        if (resu >= 1) {
            NSLog(@"str1大于str2");
        }
        if (resu == 0) {
            NSLog(@"str1 str2相等");
        }
        if (resu < 0) {
            NSLog(@"str1小于str2");
        }

//第二节代码
        // __block 的作用就是在block 块内部使函数的局部变量不仅可以被访问，而且还可以被修改（保护局部变量可以在函数的其他地方被访问和做修改，不影响其他地方的对局部变量的操作）
        //练习 ：把数组中的字符串拼接成一个字符串
//        NSArray * stsArr = [NSArray arrayWithObjects:@"Hello",@"Hello",@"39", nil];
        NSArray * strArr = @[@"Hello",@"HH",@"39"];
        NSString * (^appendString)(NSArray *) = ^(NSArray * arr){
            NSString * newStr = @"";//这里不能写成：NSString * newStr = nil;
            for (int i = 0 ; i < [arr count]; i++) {
                NSString * append = arr[i];//获取数组中每个字符串对象
                newStr = [newStr stringByAppendingString:append];//拼接功能,注意使用 newStr 去接受
            }
            return newStr;
        };
        NSString * afterAppendSting = appendString(@[@"123",@"456",@"789",@"0"]);
        NSLog(@"%@",afterAppendSting);
        
        //比较两个字符串的大小
        NSString * str1 = @"123";
        NSString * str2 = @"123";
//        BOOL (^ compareStrings)(NSString *,NSString *) = ^(NSString * str01,NSString * str02){
//            NSComparisonResult result = [str01 compare:str02];
//            return result;
//        };//这种写法是错误的

        NSComparisonResult (^ compareStrings)(NSString *,NSString *) = ^(NSString * str01,NSString * str02){
            NSComparisonResult result = [str01 compare:str02];//得到枚举的结果
            //在内部判断可以不用返回值
            if (result == NSOrderedAscending) {//升序
                NSLog(@"str1小于str2");
            }
            if (result == NSOrderedDescending) {//降序
                NSLog(@"str1大于str2");
            }
            if (result == NSOrderedSame) {//相等
                NSLog(@"str1 str2相等");
            }
            //也可以使用分支
            switch (result) {
                case NSOrderedAscending:
                     NSLog(@"str1小于str2");
                    break;
                case NSOrderedDescending:
                     NSLog(@"str1大于str2");
                    break;
                case NSOrderedSame:
                     NSLog(@"str1 str2相等");
                    break;
                default:
                    break;
            }

            return result;
        };
        
        NSComparisonResult resu = compareStrings(str1,str2);//比较的方法通过返回值在外部判断
        if (resu >= 1) {
            NSLog(@"str1大于str2");
        }
        if (resu == 0) {
            NSLog(@"str1 str2相等");
        }
        if (resu < 0) {
            NSLog(@"str1小于str2");
        }
        if (resu == NSOrderedAscending) {//升序
            NSLog(@"str1小于str2");
        }
        if (resu == NSOrderedDescending) {//降序
            NSLog(@"str1大于str2");
        }
        if (resu == NSOrderedSame) {//相等
            NSLog(@"str1 str2相等");
        }

===================== ===================== 

说明上面  字符串比较代码1  里面错误的代码是因为 

NSComparisonResult 有三个返回值（0，-1，1）  而bool只有两种情况 0 与 非0

===================== ===================== 

NSComparisonResult result = [str1  compare: str2];  // result 的返回值（值的形式很灵活）要 注意

result有下面三种值

NSOrderedAscending://-1等价

NSOrderedDescending://1等价

NSOrderedSame://0等价

 

//
//  main.m
#import <Foundation/Foundation.h>
#import "Person.h"
#import "DownLoadManager.h"
#import "LoginManage.h"

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // insert code here...
        NSLog(@"Hello, World!");
        //block练习 定义block 比较两个整数的大小
        void (^ compareTwoNum)(int a ,int b) = ^(int a, int b){
            if (a > b) {
                NSLog(@"%d 大于 %d",a,b);
            }
            if (a < b) {
                NSLog(@"%d 小于 %d",a,b);
            }
            else{
                NSLog(@"%d 等于 %d",a,b);
            }
        };
        compareTwoNum(12,45);
        //compare 是OC提供的比较的对象方法
        //把=左边的block名字去掉就是block的类型
        NSComparisonResult(^numCompare)(NSInteger,NSInteger) = ^(NSInteger a, NSInteger b){
            //数字的对象是 NSnumber
            NSNumber * object1 = [NSNumber numberWithInteger:a];
            NSNumber * object2 = [NSNumber numberWithInteger:b];
            //笑笑语法
            NSNumber * obj1 = @(a);//如果是数字的话 直接 @123 （@数字）
            NSNumber * obj2 = @(b);
            return [object1 compare:object2];
        };
         NSComparisonResult cmpResult = numCompare(45,78);
        //NSComparisonResult 是一个枚举类型既不是指针，也不是变量 （1 对应降序） （-1 对应的升序） （0 对应的是相等）
        //返回值类型根据需求而定
        NSLog(@"%ld",cmpResult);
        
        //不可变数组
        //（将block作为方法的参数）
        NSArray *arr = [NSArray arrayWithObjects:@"how",@"hai",@"what", nil];
        // NSArray * arr = @[@"hai",@"how",@"what"];
        //排序 记住排序的首字母是 Sort开头
        //sortedArrayUsingSelector 默认是升序排序 返回的是一个不可变的数组 可变是不可变的子类
        NSArray * newArr = [arr sortedArrayUsingSelector:@selector(compare:)];//相当于把原来的排好序然后拷贝一份给newArr
        NSLog(@"%@",newArr);
      
        
        
        //不可变数组两种排序
    //^NSComparisonResult(id obj1, id obj2) 这个block 作为一个参数
     /*  参数为 :^NSComparisonResult(id obj1, id obj2) {
        return [obj1 compare:obj2];
    }*/
        //下面的方法系统默认的是升序的
       NSArray * newArray = [arr sortedArrayUsingComparator:^NSComparisonResult(id obj1, id obj2) {
             return [obj1 compare:obj2];//这是返回的block方法执行后的值
           //而数组调用的sortedArrayUsingComparator方法返回一个排好序的数组
       //  return -[obj1 compare:obj2];//改变默认的排序为降序排序
       //  return [obj2 compare:obj1];//改变默认的排序为降序排序
        }];
        NSLog(@"--用Block作为参数排序--%@",newArray);
        
        
        //可变数组的排序
        NSMutableArray * mutArr = [NSMutableArray arrayWithArray:arr];
        NSMutableArray * mutArr1 = [@[@"4",@"3",@"1",@"2",]mutableCopy];//把不可变的数组转变为可变数组
        //也可以用  arrayWithArray 吧不可变数组转变为可变数组
        //排序 （排序方法名以 sort 开头）
//        mutArr1  sortedArrayUsingDescriptors:<#(NSArray *)#>
        //可变数组的排序方法
        [mutArr1  sortUsingSelector:@selector(compare:)];
        NSLog(@"普通方法：%@",mutArr1);
        /*可变数组排序默认为升序
        mutArr1 sortUsingComparator:^NSComparisonResult(id obj1, id obj2) {
            <#code#>
        }*/
        [mutArr1 sortUsingComparator:^NSComparisonResult(id obj1, id obj2) {
            NSLog(@"%@ %@",obj1,obj2);//打印观看内部比较规则
            return [obj1 compare:obj2];//默认升序
        }];
        NSLog(@"用block方法：%@",mutArr1);
        
        
        
        //创建一个数组存放 5 个 person 类的对象
        Person * per1 = [[Person alloc]initWithName:@"niujianwei" age:22 height:1.75];
        Person * per2 = [[Person alloc]initWithName:@"zhangjian" age:23 height:1.75];
        Person * per3 = [[Person alloc]initWithName:@"huangtuan" age:25 height:1.80];
        Person * per4 = [[Person alloc]initWithName:@"zhangping" age:18 height:1.67];
        Person * per5 = [[Person alloc]initWithName:@"zhanghua" age:21 height:1.70];
        NSArray * perArr = [NSArray arrayWithObjects:per1,per2,per3,per4,per5, nil];
        // NSArray * perArr2 = @[per1,per2,per3,per4,per5];
        // NSMutableArray * arrayPers = [@[@"per1",@"per2",@"per3",@"per4",@"per5"]mutableCopy];是错误的存放方法，因为人不要打“”，打了之后就是一个字符串了
//        NSArray * newarr =  [perArr sortedArrayUsingSelector:@selector(compare:)];
//        NSLog(@"对五个人排序后为%@",newarr);//这里是对象在比较不可以
        NSArray * newPerArr = [perArr sortedArrayUsingComparator:^NSComparisonResult(id obj1, id obj2) {
//            Person * per1 = obj1;
//            Person * per2 = obj2;//转化之后直接拿 per1 与 per2 比较
           return [[obj1 name]compare:[obj2 name]];
//            obj1 = (Person *)per1;//或者吧id改为 Person
//            return [obj1 compare:obj2];
        }];
        NSLog(@"%@",newPerArr);
        //按年龄的降序排序
        NSArray * newByageDes = [perArr sortedArrayUsingComparator:^NSComparisonResult(id obj1, id obj2) {
            return [@([obj2 age]) compare:@([obj1 age])];
        }];
        NSLog(@"按年龄的降序排序%@",newByageDes);
        
        //按身高排序
        NSArray * newByHeight = [perArr sortedArrayUsingComparator:^NSComparisonResult(id obj1, id obj2) {
            return  -[@([obj1 height]) compare:@([obj2 height])];
        }];
        NSLog(@"按身高的降序排序%@",newByHeight);
        
        //如果那个compare：不能满足的话，那就自己写方法
        // NSArray * newByHeight2 = [perArr sortedArrayUsingSelector:@selector(compare:)];
        //block 传值 （下载：一首歌从下载的页面传过来，从一个页面吧下载的字节，下载了多少的值传过来）
        DownLoadManager * manger = [[DownLoadManager alloc]init];
        [manger download:^(int n) {
            NSLog(@"%d",n);
        }];
        
        [manger chuanzhi:^(int n, int b) {
          NSLog(@"%d %d",n,b);
        }];

        
        LoginManage * login = [[LoginManage alloc]init];
        //block类型中的返回值把外部的值传到里面
        [login loginWihtName:@"user" password:@"1234567" success:^(NSString *accountName) {
            NSLog(@"%@",accountName);
        } failure:^BOOL(NSString *errorMessage) {
            NSLog(@"%@",errorMessage);
            return 1;//把外面的值传到里面
        }];
        
    }
    return 0;
}

//
//  Person.h
#import <Foundation/Foundation.h>

@interface Person : NSObject
{
    NSString *_name;
    NSInteger _age;
    CGFloat  _height;
}
//setter getter
- (void)setName:(NSString *)name;
- (NSString *)name;
- (void)setAge:(NSInteger)age;
- (NSInteger)age;
- (void)setHeight:(CGFloat)height;
- (CGFloat)height;
//初始化
- (id)initWithName:(NSString *)name
               age:(NSInteger)age
            height:(CGFloat)height;
//便利构造器
+ (Person *)personWithNmae:(NSString *)name
                       age:(NSInteger)age
                    height:(CGFloat)height;
- (NSString *)description;
@end

//
//  Person.m
#import "Person.h"

@implementation Person
//setter getter
- (void)setName:(NSString *)name{
    _name = name;
}
- (NSString *)name{
    return  _name;
}
- (void)setAge:(NSInteger)age{
    _age = age;
}
- (NSInteger)age{
    return _age;
}
- (void)setHeight:(CGFloat)height{
    _height = height;
}
- (CGFloat)height{
    return _height;
}
//初始化
- (id)initWithName:(NSString *)name
               age:(NSInteger)age
            height:(CGFloat)height{
    self = [super init];
    if (self) {
        _name = name;
        _age = age;
        _height = height;
    }
    return self;
}
//便利构造器
+ (Person *)personWithNmae:(NSString *)name
                       age:(NSInteger)age
                    height:(CGFloat)height{
    Person * per = [[Person alloc]initWithName:name age:age height:height];
    return per;
}
- (NSString *)description{
    return [NSString stringWithFormat:@"name: %@ age: %ld height: %.2f",_name,_age,_height];
}
@end

//
//  DownLoadManager.h
#import <Foundation/Foundation.h>

typedef void (^myBlock)(int n);
typedef void (^myBlock1)(int n,int b);
@interface DownLoadManager : NSObject
{
    
}
- (void)download:(myBlock)block;
- (void)chuanzhi:(myBlock1)block1;

//登陆场景

@end

//
//  DownLoadManager.m
#import "DownLoadManager.h"


//block类型的参数适用于回调时从里面把数据传到外面（传值的作用）
//把数据从一个类里面(当前这个类)传到另一个类里面（外面需要使用的地方）
@implementation DownLoadManager

- (void)download:(myBlock)block{
    //block 使用场景
    NSLog(@"与服务器建立连接");
    NSLog(@"开始下载");
    //模拟下载字节数
    int byte = 0;
    for (int i = 0; i < 100; i++) {
        byte = arc4random() % 100;
//        NSLog(@"下载%d",byte);
    }
    int ddd = 100;
    //把数据传到外部
    NSLog(@"开始传值");
    block(ddd);
}

- (void)chuanzhi:(myBlock1)block1{
    int bb = 100;
    int c = 0;
    block1(bb,c);
}

//登陆

@end

//
//  LoginManage.h
#import <Foundation/Foundation.h>

typedef  void (^successfulBlock) (NSString *accountName);//对于登陆成功
typedef BOOL (^failureBlock)(NSString *errorMessage);//失败的情况
@interface LoginManage : NSObject
{
    
}
-(void)loginWihtName:(NSString *)name
            password:(NSString *)password
             success:(successfulBlock)success
             failure:(failureBlock)failure;
@end

//
//  LoginManage.m
#import "LoginManage.h"

@implementation LoginManage
-(void)loginWihtName:(NSString *)name
            password:(NSString *)password
             success:(successfulBlock)success
             failure:(failureBlock)failure{
    //block类型中的返回值把外部的值传到里面
    if ([name isEqualToString:@"user"]&& [password isEqualToString:@"123456"]) {
        NSLog(@"登陆成功");
        //回调并传递信息
        success (name);//把name 传出去
    }else{
        //我们从外部得到的返回值给 result
       BOOL result  = failure(@"账户或密码错误！");
        if (result) {
            NSLog(@"错误已经处理");
        }
        else{
            NSLog(@"错误没有处理");
        }
    }
}
@end

 =====实战=====

1.定义一个Block，返回值为bool,有两个NSString 实现判断两个字符串是否相等。

2.创建一个数组，初始化为@“123”，@“21”，@“33”，@“69”，@“108”，@“256”使用Block，进行数组排序，并输出内容

3.定义一个Block，返回值为NSInteger ,有两个参数，一个是NSArray 一个是NSString，实现判断数组时候包含此字符串，如果包含，返回字符串下标，如果不包含返回-1.

//
//  main.m
#import <Foundation/Foundation.h>

int main(int argc, const char * argv[]) {
    @autoreleasepool {
//        1.定义一个Block，返回值为bool,有两个NSString 实现判断两个字符串是否相等。
//        
//        2.创建一个数组，初始化为@“123”，@“21”，@“33”，@“69”，@“108”，@“256”使用Block，进行数组排序，并输出内容
//        
//        3.定义一个Block，返回值为NSInteger ,有两个参数，一个是NSArray 一个是NSString，实现判断数组时候包含此字符串，如果包含，返回字符串下标，如果不包含返回-1.
        printf("输入两个字符串
");
        char str[2][10] = {0};
        NSMutableArray * arrr = [NSMutableArray array];
        for (int i = 0; i < 2; i++) {
            scanf("%s",str[i]);
            arrr[i] = [[NSString alloc]initWithUTF8String:str[i]];
        }
        BOOL (^isEqualTwoString)(NSString *,NSString *) = ^(NSString * str1 ,NSString *str2){
            return [str1 isEqualToString:str2];
        };
        int i = isEqualTwoString(arrr[0],arrr[1]);
        if (i) {
            NSLog(@"相等");
        }else{
            NSLog(@"不相等");
        }
        
        
        //第二题
        NSArray * arr = @[@"123",@"21",@"33",@"69",@"108",@"256"];
        printf("选择排序方法（1，2，3）");
        int chose = 0;
        scanf("%d",&chose);
        switch (chose) {
            case 1:
            {
                NSArray * newArr = [arr sortedArrayUsingSelector:@selector(compare:)];
                NSLog(@"%@",newArr);
            }
                break;
            case 2:
            {
                NSArray * newArr1 = [arr sortedArrayUsingComparator:^NSComparisonResult(id obj1, id obj2) {
                    return [obj1 compare:obj2];
                }];

                NSLog(@"%@",newArr1);
            }
                break;
            case 3:
            {
                NSArray * newArr2 = [arr sortedArrayWithOptions:(NSSortOptions)1 usingComparator:^NSComparisonResult(id obj1, id obj2) {
                   return [obj1 compare:obj2];
                }];
                NSLog(@"%@",newArr2);
            }
                break;
                
            default:
                NSLog(@"输入错误");
                break;
        }
        
        
        
        
        //第三题
        NSInteger (^ workForArrAndStr) (NSArray * ,NSString *) = ^(NSArray * arr1,NSString * str1){
            NSInteger i = 0;
            for (NSString * object in arr1) {
                i++;
                if (object == str1) {
                    return i;
                    break;
                }
            }
            NSInteger b = -1;
            return b;
        };
        NSArray * array = @[@"hello",@"HHH",@"heman",@"china",@"nanyang"];
        NSString * string = @"hello";
        NSInteger n = workForArrAndStr(array,string);
        if (n == -1) {
            NSLog(@"没有找到");
        }else{
            NSLog(@"所在下标为：%lu",n - 1);
        }
    }
    return 0;
}

 参考

- (NSArray *)sortedArrayWithOptions:(NSSortOptions)opts usingComparator:(NSComparator)cmptr

opts 为0或1 是指定排序的某个条件（是否并发和稳定）。

根据我的测试，数组里有65000个元素进行排序，

opts 为1 明显要比opts 为0 快得多。
(NSComparator)cmptr 这个就是排序 

 ===========

1.compare在使用的时候是对OC里面对象的比较要是比较 NSinterger 的两个数字，需要转换为 NSNumber ，转化方法为：NSinterger b =100; NSNumber * bb = @(b);也可以  NSNumber * bb = @100;数字的话直接 @数字

2.NSComparisonResult 是一个枚举类型既不是指针，也不是变量 （1 对应降序） （-1 对应的升序） （0 对应的是相等）他的值只有这三个

3.block 作为参数的理解

 //不可变数组两种排序

    //^NSComparisonResult(id obj1, id obj2) 这个block 作为一个参数

     /*  参数为 :^NSComparisonResult(id obj1, id obj2) {

        return [obj1 compare:obj2];

    }*/

        //下面的方法系统默认的是升序的

       NSArray * newArray = [arr sortedArrayUsingComparator:^NSComparisonResult(id obj1, id obj2) {

             return [obj1 compare:obj2];//这是返回的block方法执行后的值

           //而数组调用的sortedArrayUsingComparator方法返回一个排好序的数组

       //  return -[obj1 compare:obj2];//改变默认的排序为降序排序（注意前面加了一个 -号，默认为升序加一个 负号就是降序）

       //  return [obj2 compare:obj1];//改变默认的排序为降序排序

        }];

        NSLog(@"--用Block作为参数排序--%@",newArray);

4.在有compare比较后的函数的返回值  可用  NSComparisonResult

 5.注意在创建好Person的对象之后在添加到数组的时候，不要忘了，添加的是person对象，不能写成字符串

（错误例子：NSMutableArray * arrayPers = [@[@"per1",@"per2",@"per3",@"per4",@"per5"]mutableCopy];）

6.Block使用的时候可以当做参数，（注意与函数的回调相联系）

一、概述
Block是C级别的语法和运行时特性。Block比较类似C函数，但是Block比之C函数，其灵活性体现在栈内存、堆内存的引用，我们甚至可以将一个Block作为参数传给其他的函数或者Block。

二、热身
先看一个比较简单的Block例子：

int multiplier = 7; 
int (^myBlock)(int) = ^(int num) { 
    return num * multiplier; 
}; 
在这个例子中，myBlock是一个Block变量，它接受一个int类型的参数，返回一个int类型的值。是不是很像C函数？

来，让我们typedef一下

typedef void (^BoolBlock)(BOOL);//一个只接受一个BOOL参数，没有返回值的block 
typedef int (^IntBlock)(void);//一个没有参数，返回int的block 
typedef BoolBlock (^HugeBlock)(IntBlock);//看看，这个HugeBlock的参数和返回值都是block 
三、更详细的例子
注意：上面的typedef都还有效~

主动调用一下：

- (void)someMethod 
{ 
    BoolBlock ablock = ^(BOOL bValue) { 
        NSLog(@"Bool block!"); 
    }; 
    ablock(); 
} 
作为参数返回：

typedef void (^BoolBlock)(BOOL); 
- (BoolBlock)foo() 
{ 
    BoolBlock ablock = ^(BOOL bValue) { 
        NSLog(@"Bool block!"); 
    }; 
    return [[ablock copy] autorelease];//一定要copy，将其复制到堆上，更详细的原理，将在后续章节讲解 
} 
类的一个成员：

@interface OBJ1 : NSObject 
@property (nonatomic, copy)BoolBlock block;//理由同上啊，同学们 
@end 
 
OBJ1 *obj1 = ... 
obj1.block = ^(BOOL bValue) { 
        NSLog(@"Bool block!"); 
    }; 
其他函数的参数：

- (void)foo(BoolBlock block) 
{ 
    if (block) { 
        block(); 
    } 
} 
甚至其他block的参数：

BoolBlock bBlock = ^(BOOL bV){if(Bv){/*do some thing*/}}; 
HugeBlock hBlock = ^(BoolBlock bB) {bB();}; 
 
hBolck(bBlock); 
啊，全局变量！：

static int(^maxIntBlock)(int, int) = ^(int a, int b){return a>b?a:b;}; 
int main() 
{ 
    printf("%d
", maxIntBlock(2,10));   
    return 0; 
} 
好了，你知道block大概能怎么用了。

四，特殊的标记，__block
如果要在block内修改block外声明的栈变量，那么一定要对该变量加__block标记：

int main() 
{ 
    __block int i = 1024; 
    BoolBlock bBlock = ^(BOOL bV) { 
        if (bV) { 
            i++;//如果没有__block标记，是无法通过编译的。 
        } 
    }; 
} 

参考1  参考2