ObjC第六节:OC常用类

最新推荐文章于 2022-07-25 17:00:43 发布

dot2636268966

最新推荐文章于 2022-07-25 17:00:43 发布

阅读量429

点赞数

文章标签： ObjC课程

本文链接：https://blog.csdn.net/dot2636268966/article/details/47775435

版权

OC常用类:Foundation、NSObject、NSNumber、NSString

1、Foundation

1.1 一个框架是由类、方法、函数、文档组合在一起构成的集合，使程序开发更容易

1.2 Foundation可以使用一些基本的类，如数字类、字符串类、集合类等

1.3 AppKit框架包含的类或方法，可以用于开发交互式的图形应用程序，对文本框、工具栏、菜单、表等进行操作

1.4 Foundation框架中的类：

数据存储类：NSData、NSString、NSArray、NSDictionary、NSSet

文本和字符串类：NSCharacterSet、NSString

时间日期类：NSDate、NSTimeZone、NSCalendar

应用程序通知类：NSNotification、NSNotificationCenter

对象创建和处理类：NSAutoreleasePool

对象的空间分配和持久化：NSCoder

操作系统服务类：NSFileManager、NSThread

URL系统加载类：NSURL

2、NSObject

3、NSNumber

1.1 不能向基本数据类型发消息，不能使用NSArray保存基本数据类型数据，就需要NSNumber的装箱（把基本数据类型数据包装成对象）

1.2 NSNumber * intNum = [NSNumber numberWithInt:10]; //类方法

NSNumber * intNum =[ [NSNumber alloc] initWithInt:10]; //实例方法

int nn = [intNum intValue];

4、NSString

NSString copy和mutableCopy

//compare区分大小写，compare:options:,可以拥有更多控制权
//- (NSComparisonResult) compare:(NSString *) String options:(unsigned) mask;
//options参数是一个 位掩码，可以用位或运算符|来添加选项标记，如下常用选项
//NSCaseInsensitiveSearch不区分大小写
//NSLiteralSearch进行完全比较，区分大小写
//NSNumericSearch比较里面的数字
//如忽略大小写但按照字符个数的多少排序：
//if （[A compare: B options:NSCaseInsensitiveSearch | NSNumbericSearch] == NSOrderedSame）{...}
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[])
{
    @autoreleasepool
    {
        //关于copy、mutableCopy(非容器类如NSString、NSNumber)
        NSString * s = @"abcd";  //s与scopy地址一样，即不可变copy其实是浅拷贝，因指向常量区
        NSLog(@"%@, %p", s, s);
        NSString * scopy = [s copy];
        NSLog(@"%@, %p", scopy, scopy);
        NSMutableString * sMutable = [s mutableCopy];  //不可变对象+可变拷贝=可变对象。可变拷贝实现了深拷贝
        NSLog(@"%@, %p", sMutable, sMutable);
        [sMutable appendString:@"efg"];
        NSLog(@"%@, %p", sMutable, sMutable);
        
        
        //关于string、mutableString
        NSMutableString *mutableS = [NSMutableString stringWithString: @"abab"];
        
        NSLog(@"11%@, %p", mutableS, mutableS);
        NSString *stringCopy = [mutableS copy];  //可变对象+copy=不可变对象
        NSLog(@"22%@, %p", stringCopy, stringCopy);
        NSMutableString *mStringCopy = [mutableS copy];  //即使定义成可变对象它也不会是可变对象，其实还是不可变对象
        NSLog(@"33%@, %p", mStringCopy, mStringCopy);
        
        NSMutableString *mStringMCopy = [mutableS mutableCopy];
        NSLog(@"44%@, %p", mStringMCopy, mStringMCopy);
        NSString *stringMCopy = [mutableS mutableCopy];  //即使定义成不可变，可变对象+可变拷贝=可变对象，依然成立。原因可能是？？
        NSLog(@"55%@, %p", stringMCopy, stringMCopy);
        
        [mutableS appendString:@"11"];
        NSLog(@"11%@, %p", mutableS, mutableS);
        
        //[stringCopy appendString:@"22"];  //崩溃
        //NSLog(@"22%@, %p", stringCopy, stringCopy);
        //[mStringCopy appendString:@"33"];   //崩溃
        //NSLog(@"33%@, %p", mStringCopy, mStringCopy);
        
        [mStringMCopy appendString:@"44"];
        NSLog(@"44%@, %p", mStringMCopy, mStringMCopy);
        [stringMCopy appendString:@"55"];  //警告:可能无响应(因为NSString没有该方法)
        NSLog(@"55%@, %p", stringMCopy, stringMCopy);
        //可得出结论，无论定义成NSString还是NSMutableString，无论被拷贝的对象可变还是不可变，只要是copy，都生成了不可变对象，只要是mutableCopy，都生成了可变对象
        //对于系统的非容器类对象(NSString、NSNumber)，我们可以认为，如果对不可变对象复制，copy是指针复制（浅拷贝）,mutableCopy是对象复制（深拷贝）。如果是对可变对象复制，都是深拷贝，但是copy返回的对象是不可变的
        
        
        //关于copy、mutableCopy(容器类如NSArray、NSDictionary),与非容器一样
        NSArray *array1 = [NSArray arrayWithObjects:@"a", @"b", @"c", nil];
        NSArray *arrayCopy1 = [array1 copy];
        //arrayCopy1和array是同一个NSArray对象（指向相同的对象），包括array里面的元素也是指向相同的指针
        NSLog(@"array1 retain count: %ld, %p",[array1 retainCount], array1);//地址相同
        NSLog(@"array1 retain count: %ld, %p",[arrayCopy1 retainCount], arrayCopy1);
        NSMutableArray *mArrayCopy1 = [array1 mutableCopy];
        //mArrayCopy1是array1的可变副本，指向的对象和array1不同，但是其中的元素和array1中的元素指向的是同一个对象。mArrayCopy1还可以修改自己的对象
        [mArrayCopy1 addObject:@"de"];
        [mArrayCopy1 removeObjectAtIndex:0];
        //array1和arrayCopy1是指针复制，而mArrayCopy1是对象复制，mArrayCopy1还可以改变其内的元素：删除或添加。但是注意的是，容器内的元素内容都是指针复制。
        
        //关于array、mutableArray
        NSMutableArray * muArray = [NSMutableArray arrayWithObjects:@"a", @"b", nil];
        NSArray * arrCopy = [muArray copy];
        NSLog(@"11%@", arrCopy);
        NSArray * arrMuCopy = [muArray mutableCopy];
        NSLog(@"22%@", arrMuCopy);
        NSMutableArray * muArrayCopy = [muArray copy];
        NSLog(@"33%@", muArrayCopy);
        NSMutableArray * muArrayMuCopy = [muArray mutableCopy];
        NSLog(@"44%@", muArrayMuCopy);
        
        //[arrCopy insertObject:@"C" atIndex:1];  //崩溃
        //NSLog(@"11%@", arrCopy);
        [arrMuCopy insertObject:@"C" atIndex:1];
        NSLog(@"22%@", arrMuCopy);
        //[muArrayCopy insertObject:@"C" atIndex:1];  //崩溃
        //NSLog(@"33%@", muArrayCopy);
        [muArrayMuCopy insertObject:@"C" atIndex:1];
        NSLog(@"44%@", muArrayMuCopy);
        //可得出结论：与非容器类相同，但仅针对数组(字典)本身，其中的对象依然是浅拷贝
        
        
        //方法1.直接赋值:
        NSString *str1 = @"my string";
        NSLog(@"%p", str1);
        //方法2.类函数初始化生成:
        NSString *str2 = [NSString stringWithString:@"my string"];
        NSLog(@"%p", str2);
        NSString *str5 = [NSString stringWithFormat:@"%@", @"my string"];
        NSLog(@"%p", str5);
        //方法3.实例方法初始化生成:
        NSString *str3 = [[NSString alloc] initWithString:@"my string"];
        NSLog(@"%p", str3);
        NSString *str4 = [[NSString alloc] initWithFormat:@"my string"];
        NSLog(@"%p", str4);

        
        
//        NSString *str = [[NSString alloc] initWithString:@"ABC"];
//        str = @"123";
//        [str release];
//        NSLog(@"%@",str);
//        第一句 声明了一个NSString类型的实例 str，初始化后init后，其内部的字符串"ABC"在堆区。格式化初始字符串我试验了下发现"A-Z,a-z"retainCount都还是 -1，而“AA，aa”一旦字符超过一个就会在堆区创建，retainCount 都会变成 1.
//        第二行，将str的指针指向了一个常量@"123"。理论上讲在第一行初始化的堆上的@"ABC"没有任何任何指针指向了。所以造成了内存泄露。但是，因为NSString是系统提供的类，其涉及常量区，或许会有特殊的规则来解决
//        然后第三行， 将str的引用计数-1
//        第四行输出str的值  为123.
//        为什么不会崩溃？ 因为第三行的release 实际上是release了一个常量@"123"  而作为常量，其默认的引用计数值是整形最大值。因为超出了短整形的范围。所以采用%d ，retainCount输出时，输出值为 -1.若用%ld 输出，是整形最大值
//        区别1:方法一生成字符串时,不会初始化内存空间,所以使用结束后不会释放内存;
//        　　　而其他三个都会初始化内存空间,使用结束后要释放内存;
//        　　　在释放内存时方法2和3也不同,方法2是autorelease类型,内存由系统释放;方法3则必须手动释放
//        区别2:用Format初始化的字符串，需要初始化一段动态内存空间，如：0x6a42a40;
//             而用String声明的字符串，初始化的是常量内存区，如：0x46a8，常量内存区的地址，只要值相同，占用的地址空间是一致的。
//             所以str3和str1的地址一致，但是str4和str1的地址不一致。
        
        
        
#warning 心好累，这些还没试
//        //下面用另一个例子来测试一下。
//        NSArray *mArray1 = [NSArray arrayWithObjects:[NSMutableString stringWithString:@"a"],@"b",@"c",nil];
//        NSArray *mArrayCopy2 = [mArray1 copy];
//        NSLog(@"mArray1 retain count: %ld",[mArray1 retainCount]);
//        NSMutableArray *mArrayMCopy1 = [mArray1 mutableCopy];
//        NSLog(@"mArray1 retain count: %ld",[mArray1 retainCount]);
//        //mArrayCopy2,mArrayMCopy1和mArray1指向的都是不一样的对象，但是其中的元素都是一样的对象——同一个指针
//        //一下做测试
//        NSMutableString *testString = [mArray1 objectAtIndex:0];
//        //testString = @"1a1";//这样会改变testString的指针，其实是将@“1a1”临时对象赋给了testString
//        [testString appendString:@" tail"];//这样以上三个数组的首元素都被改变了
//        //由此可见，对于容器而言，其元素对象始终是指针复制。如果需要元素对象也是对象复制，就需要实现深拷贝。http://developer.apple.com/library/mac/#documentation/Cocoa/Conceptual/Collections/Articles/Copying.html
//        NSArray *array = [NSArray arrayWithObjects:[NSMutableString stringWithString:@"first"],[NSString stringWithString:@"b"],@"c",nil];
//        NSArray *deepCopyArray=[[NSArray alloc] initWithArray: array copyItems: YES];
//        NSArray* trueDeepCopyArray = [NSKeyedUnarchiver unarchiveObjectWithData:[NSKeyedArchiver archivedDataWithRootObject: array]];
//        //trueDeepCopyArray是完全意义上的深拷贝，而deepCopyArray则不是，对于deepCopyArray内的不可变元素其还是指针复制。或者我们自己实现深拷贝的方法。因为如果容器的某一元素是不可变的，那你复制完后该对象仍旧是不能改变的，因此只需要指针复制即可。除非你对容器内的元素重新赋值，否则指针复制即已足够。举个例子，[[array objectAtIndex:0] appendstring:@”sd”]后其他的容器内对象并不会受影响。[[array objectAtIndex:1]和[[deepCopyArray objectAtIndex:0]尽管是指向同一块内存，但是我们没有办法对其进行修改——因为它是不可改变的。所以指针复制已经足够。所以这并不是完全意义上的深拷贝，但是apple的官方文档将其列为deep copy了，并添加了copy和mutablity的关系说明，故在此做一说明

    }
    return 0;
}

NSNumber

//NSNumber
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[])
{
    NSNumber * intNum = [NSNumber numberWithInt:2];  //类方法新建并赋值
    NSNumber * charNum = [NSNumber numberWithChar:'A'];
    //+ (NSNumber *)numberWithBool:(BOOL)value
    //bool/char/double/float/int/integer/long/longlong/short/unsignedShort/unsignedChar/unsignedInt/unsignedInteger/unsignedlong/unsignedlonglong/

    NSNumber * boolNum = [[NSNumber alloc] initWithBool:1];  //实例方法创建
    //- (NSNumber *)initWithBool:(BOOL)value
    
    int intn = [intNum intValue];  //取值
    //@property(readonly) BOOL boolValue   stringValue
    
//    Compare
//    decimalValue
//    descriptionWithLocale
//    isEqualToNumber
    
    - (const char *)objCType  Returns a C string containing the Objective-C type of the data contained in the number object.
    objCType
    NSLog(@"%s", [charNum objCType]);
    
    - (BOOL)isEqualToNumber:(NSNumber *)aNumber   //比较是否相等
    bool b = [intNum isEqualTo:boolNum];
    NSLog(@"%d", b);
    
    - (NSString *)descriptionWithLocale:(id)aLocale   Returns a string that represents the contents of the number object for a given locale
    NSString * str1 = [boolNum descriptionWithLocale:charNum];
    NSLog(@"%@", str1);
    
    @property(readonly) NSDecimal decimalValue    The number object's value expressed as an NSDecimal structure. (read-only)对象的值表示为一个NSDecimal数量结构。(只读)
    NSDecimal  d = [intNum decimalValue];
    NSLog(@"%ld", d);
    
    - (NSComparisonResult)compare:(NSNumber *)aNumber
    NSLog(@"%ld", [intNum compare:boolNum]);
    return 0;
}

NSString

//NSString
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[])
{
    NSString * str1 = @"abcd";
    unsigned long len = [str1 length];  //长度
    NSString * str2 = [str1 stringByAppendingString:@"efg"];  //连接
    NSString * str3 = [NSString stringWithFormat:@"%ld%@", len, str2];  //格式化创建
    
    if([str3 isEqualToString:@"4abcdefg"])  //比较
    {
        NSLog(@"%ld",[str2 compare:str1 options:NSCaseInsensitiveSearch range:[str2 rangeOfString:str1]]);  //增加条件和范围的比较
    }
    unichar c = [str1 characterAtIndex:1];
    int i = [str1 intValue];
    char * s = [str1 UTF8String];
    str1 = [str1 uppercaseString];  //大小写
    str2 = [@"EFGH" lowercaseString];
    str3 = [str1 substringToIndex:2];   //求子串
    str3 = [str2 substringFromIndex:2];
    str3 = [str3 substringWithRange:NSMakeRange(0, 2)];
    NSString * str4 = [NSString stringWithFormat:@"%@%@%@", str1, str2, str3];
    NSLog(@"%@", str4);
    
    return 0;
}

//NSMutableString
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[])
{
    NSMutableString * str1 = [NSMutableString stringWithString:@"ab"];
    [str1 appendString:@"cd"];
    [str1 appendFormat:@"ab%d", 12];
    [str1 insertString:@"ee" atIndex:8];
    [str1 deleteCharactersInRange:[str1 rangeOfString:@"ab"]];//只删除第一个
    [str1 setString:str1];
    
    NSLog(@"%@", str1);
    
    [str1 replaceCharactersInRange:[str1 rangeOfString:@"12"] withString:@"ab"];
    [str1 replaceOccurrencesOfString:[str1 substringWithRange:NSMakeRange(2, 2)] withString:str1 options:NSBackwardsSearch range:NSMakeRange(2, [str1 length]-4)];

    NSLog(@"%@", str1);
    NSArray * arr = [str1 componentsSeparatedByString:@"b"];
    NSLog(@"%@", arr);
    return 0;
}

NSString

#import <Foundation/Foundation.h>
int main(int argc, const char * argv[])
{
#pragma mark --创建并初始化字符串
//    NSString * str1 = [NSString string];   //类方法，空字符串
//    [str1 init];    //实例方法，返回一个没有元素的初始化了的字符串
//    
//    //[str1 initWithBytes:<#(const void *)#> length:<#(NSUInteger)#> encoding:<#(NSStringEncoding)#>];
//    //Returns an initialized NSString object containing a given number of bytes from a given buffer of bytes interpreted in a given encoding.
//    
//    //[str1 initWithBytesNoCopy:<#(void *)#> length:<#(NSUInteger)#> encoding:<#(NSStringEncoding)#> freeWhenDone:<#(BOOL)#>]
//    //Returns an initialized NSString object that contains a given number of bytes from a given buffer of bytes interpreted in a given encoding, and optionally frees the buffer.
//    
//    //const unichar *c = "aa";
//    //[str1 initWithCharacters:c length:2];
//    //Returns an initialized NSString object that contains a given number of characters from a given C array of Unicode characters.
//    
//    //[str1 initWithCharactersNoCopy:<#(unichar *)#> length:<#(NSUInteger)#> freeWhenDone:<#(BOOL)#>]
//    
//    [str1 initWithString:@"aa"];  //返回通过拷贝另一个已经给出的字符串来初始化的字符串
//    
//    //[str1 initWithCString:"aa" encoding:];
//    
//    //[str1 initWithUTF8String:"aaa"];  //by copying the characters from a given C array of UTF8-encoded bytes.
//    
//    [str1 initWithFormat:@"%d", 1];
//    //[str1 initWithFormat:<#(NSString *)#> arguments:<#(__va_list_tag *)#>]
//    //[str1 initWithFormat:<#(NSString *)#> locale:<#(id), ...#>]
//    //[str1 initWithFormat:<#(NSString *)#> locale:<#(id)#> arguments:<#(__va_list_tag *)#>]
//    
//    //[str1 initWithData:<#(NSData *)#> encoding:<#(NSStringEncoding)#>]//用给出的编码方式把给出的data转换成Unicode字符
//    
//    
//    NSString * str2 = [NSString stringWithFormat:@":"];
//    //[NSString localizedStringWithFormat:@"1"]
//    //[NSString stringWithCharacters:@"1" length:2];
//    //[NSString stringWithString:@"1"];
//    //[NSString stringWithCString:"a" encoding:<#(NSStringEncoding)#>];
//    //[NSString stringWithUTF8String:"a"];
//    
//    
#pragma mark  --从文件创建并初始化字符串
//    NSString * str3 = [NSString stringWithContentsOfFile:@"/Users/len/Desktop/word.rtf" usedEncoding:NSUTF8StringEncoding error:nil];
//    //[str3 initWithContentsOfFile:@"" encoding:<#(NSStringEncoding)#> error:<#(NSError **)#>]
//    //+ (instancetype)stringWithContentsOfFile: usedEncoding: error:
//    //- (instancetype)initWithContentsOfFile: usedEncoding: error:
    
    
#pragma mark --从URL创建并初始化字符串
//    + (instancetype)stringWithContentsOfURL: encoding: error:
//    - (instancetype)initWithContentsOfURL: encoding: error:
//    //+ (instancetype)stringWithContentsOfURL: usedEncoding: error:
//    //- (instancetype)initWithContentsOfURL: usedEncoding: error:
    
    
#pragma mark --写入文件或URL
    //- (BOOL)writeToFile:(NSString *)path  atomically:(BOOL)useAuxiliaryFile  encoding:(NSStringEncoding)enc  error:(NSError **)error
    //- (BOOL)writeToURL:(NSURL *)url  atomically:(BOOL)useAuxiliaryFile  encoding:(NSStringEncoding)enc  error:(NSError **)error
    
    
#pragma mark --字符串长度
//    @property(readonly) NSUInteger length
//    long len = [str length];
    
    //- (NSUInteger)lengthOfBytesUsingEncoding:(NSStringEncoding)enc
    //Returns the number of bytes required to store the receiver in a given encoding.
    
    //- (NSUInteger)maximumLengthOfBytesUsingEncoding:(NSStringEncoding)enc
    //Returns the maximum number of bytes needed to store the receiver in a given encoding
    
    
#pragma mark --字符串字符
    //- (unichar)characterAtIndex:(NSUInteger)index  //输出数组给定位置的字符
    NSString * str = @"abcd";
    unichar c = [str characterAtIndex:1];

    //- (void)getCharacters:(unichar *)buffer  range:(NSRange)aRange
    [str getCharacters:@"a" range:NSMakeRange(1, 2)];  //??
    
    //- (BOOL)getBytes:(void *)buffer  maxLength:(NSUInteger)maxBufferCount  usedLength:(NSUInteger *)usedBufferCount  encoding:(NSStringEncoding)encoding  options:(NSStringEncodingConversionOptions)options  range:(NSRange)range  remainingRange:(NSRangePointer)leftover
    
    
#pragma mark --得到C字符串
//    - (const char *)cStringUsingEncoding:(NSStringEncoding)encoding
//    
//    @property(readonly) const char *UTF8String  //A null-terminated UTF8 representation of the string. (read-only)
    
    
#pragma mark --组合字符串
//    - (NSString *)stringByAppendingFormat:(NSString *)format
//    
//    - (NSString *)stringByAppendingString:(NSString *)aString
//    
//    - (NSString *)stringByPaddingToLength:(NSUInteger)newLength  withString:(NSString *)padString  startingAtIndex:(NSUInteger)padIndex
//    //Returns a new string formed from the receiver by either removing characters from the end, or by appending as many occurrences as necessary of a given pad string.
    
    
#pragma mark --切分字符串
    - (NSArray *)componentsSeparatedByString:(NSString *)separator
    - (NSArray *)componentsSeparatedByCharactersInSet:(NSCharacterSet *)separator
    - (NSString *)substringFromIndex:(NSUInteger)anIndex
    - (NSString *)substringWithRange:(NSRange)aRange
    - (NSString *)substringToIndex:(NSUInteger)anIndex
    
#pragma mark --查找字符和子串
    - (NSRange)rangeOfCharacterFromSet:(NSCharacterSet *)aSet
    - (NSRange)rangeOfCharacterFromSet:(NSCharacterSet *)aSet  options:(NSStringCompareOptions)mask
    - (NSRange)rangeOfCharacterFromSet:(NSCharacterSet *)aSet  options:(NSStringCompareOptions)mask   range:(NSRange)aRange
    - (NSRange)rangeOfString:(NSString *)aString
    - (NSRange)rangeOfString:(NSString *)aString   options:(NSStringCompareOptions)mask   range:(NSRange)aRange   locale:(NSLocale *)locale
    
#pragma mark --替换子串
    - (NSString *)stringByReplacingOccurrencesOfString:(NSString *)target   withString:(NSString *)replacement   options:(NSStringCompareOptions)options   range:(NSRange)searchRange
    - (NSString *)stringByReplacingCharactersInRange:(NSRange)range    withString:(NSString *)replacement
    return 0;
}