OC学习16——对象归档

转载自  OC学习篇之---归档和解挡

OC中的归档就是将对象写入到一个文件中，Java中的ObjectInputStream和ObjectOutputStream来进行操作的。当然在操作的这些对象都是需要实现一个接口：Serializable,同样的OC中操作的对象也是需要实现一个协议的，后面会说到。

一、已有类型的归档和解档

首先来看一个简单的例子：

 1 //
 2 //  main.m
 3 //  33_ObjectToFile
 4 //
 5 //  Created by jiangwei on 14-10-13.
 6 //  Copyright (c) 2014年 jiangwei. All rights reserved.
 7 //
 8
 9 #import <Foundation/Foundation.h>
10
11 //归档：将一个对象写到文件中
12 int main(int argc, const charchar * argv[]) {
13     @autoreleasepool {
14        //第一种形式：归档对象
15        //对象----》文件
16         /*
17         NSArray *array = [NSArray arrayWithObjects:@"zhang",@"wangwu",@"lisi",nil];
18         NSString *filePath = [NSHomeDirectory() stringByAppendingPathComponent:@"array.src"];
19
20         BOOL success = [NSKeyedArchiver archiveRootObject:array toFile:filePath];
21         if(success){
22             NSLog(@"保存成功");
23         }
24          */
25         /*解归档
26         NSString *filePath = [NSHomeDirectory() stringByAppendingPathComponent:@"array.src"];
27         id array = [NSKeyedUnarchiver unarchiveObjectWithFile:filePath];
28         NSLog(@"%@",array);
29          */
30
31         //第二种方式
32         //第一种方式的缺陷是一个对象归档成一个文件
33         //但是第二种方式，多个对象可以归档成一个文件
34         /*
35         NSArray *array = [NSArray arrayWithObjects:@"zhangsan",@"lisi", nil];
36         NSMutableData *data = [NSMutableData data];
37         NSKeyedArchiver *archiver = [[NSKeyedArchiver alloc] initForWritingWithMutableData:data];
38         //编码
39         [archiver encodeObject:array forKey:@"array"];
40         [archiver encodeInt:100 forKey:@"scope"];
41         [archiver encodeObject:@"jack" forKey:@"name"];
42
43         //完成编码，将上面的归档数据填充到data中，此时data中已经存储了归档对象的数据
44         [archiver finishEncoding];
45         [archiver release];
46
47         NSString *filePath = [NSHomeDirectory() stringByAppendingPathComponent:@"array.src"];
48         BOOL success = [data writeToFile:filePath atomically:YES];
49         if(success){
50             NSLog(@"归档成功");
51         }
52          */
53
54         NSString *filePath = [NSHomeDirectory() stringByAppendingPathComponent:@"array.src"];
55         //读取归档数据
56         NSData *data = [[NSData alloc] initWithContentsOfFile:filePath];
57
58         //创建解归档对象，对data中的数据进行解归档
59         NSKeyedUnarchiver *unarchiver = [[NSKeyedUnarchiver alloc] initForReadingWithData:data];
60
61         //解归档
62         NSArray *array = [unarchiver decodeObjectForKey:@"array"];
63         NSLog(@"%@",array);
64
65         int value = [unarchiver decodeObjectForKey:@"scope"];
66         NSLog(@"%d",value);
67
68
69
70
71     }
72     return 0;
73 }

1、归档

1 //第一种形式：归档对象
2 //对象----》文件
3  NSArray *array = [NSArray arrayWithObjects:@"zhang",@"wangwu",@"lisi",nil];
4  NSString *filePath = [NSHomeDirectory() stringByAppendingPathComponent:@"array.src"];
5
6  BOOL success = [NSKeyedArchiver archiveRootObject:array toFile:filePath];
7  if(success){
8      NSLog(@"保存成功");
9  }

我们这里将一个NSArray对象写入到一个文件中。

这里说到了创建一个文件的方法：

NSString *filePath = [NSHomeDirectory() stringByAppendingPathComponent:@"array.src"];

我们可以打印一下filePath的值：

我们查看一下array.src的内容：我们看到内容是乱的，但是我们貌似还是能看到一点，比如wangwu/lisi等字眼，说明在归档的时候并没有深入的加密。

2、解档

1 //解归档
2 NSString *filePath = [NSHomeDirectory() stringByAppendingPathComponent:@"array.src"];
3 id array = [NSKeyedUnarchiver unarchiveObjectWithFile:filePath];
4 NSLog(@"%@",array);

解档也是很简单的，就是返回一个对象，不过这里用了id类型的，因为读出来也不确定是哪种类型的。

3、对多个对象进行归档到一个文件

 1 /第二种方式
 2 //第一种方式的缺陷是一个对象归档成一个文件
 3 //但是第二种方式，多个对象可以归档成一个文件
 4  NSArray *array = [NSArray arrayWithObjects:@"zhangsan",@"lisi", nil nil];
 5  NSMutableData *data = [NSMutableData data];
 6  NSKeyedArchiver *archiver = [[NSKeyedArchiver alloc] initForWritingWithMutableData:data];
 7  //编码
 8  [archiver encodeObject:array forKey:@"array"];
 9  [archiver encodeInt:100 forKey:@"scope"];
10  [archiver encodeObject:@"jack" forKey:@"name"];
11
12  //完成编码，将上面的归档数据填充到data中，此时data中已经存储了归档对象的数据
13  [archiver finishEncoding];
14  [archiver release];
15
16  NSString *filePath = [NSHomeDirectory() stringByAppendingPathComponent:@"array.src"];
17  BOOL success = [data writeToFile:filePath atomically:YES];
18  if(success){
19  NSLog(@"归档成功");
20  }

多个对象归档的话，这里要用到一个类：NSMutableData和NSData，他们两的区别很简单，一个是可变的，一个是不可变的。然后这里还创建了一个归档器：NSKeyedArchiver,这个类负责进行指定类型的编码操作，然后将数据填充到NSMutableData类。归档的时候对每个类型对象用一个key进行对应，这个NSData和NSDirctionary很类似了。

4、对多个对象进行解档操作

 1 NSString *filePath = [NSHomeDirectory() stringByAppendingPathComponent:@"array.src"];
 2 //读取归档数据
 3 NSData *data = [[NSData alloc] initWithContentsOfFile:filePath];
 4
 5 //创建解归档对象，对data中的数据进行解归档
 6 NSKeyedUnarchiver *unarchiver = [[NSKeyedUnarchiver alloc] initForReadingWithData:data];
 7
 8 //解归档
 9 NSArray *array = [unarchiver decodeObjectForKey:@"array"];
10 NSLog(@"%@",array);
11
12 int value = [unarchiver decodeObjectForKey:@"scope"];
13 NSLog(@"%d",value);

我们可以将文件解档出一个NSData对象，然后可以通过key去获取指定的类型对象

二、自定义类型的归档和解档

上面说到了已有类型的归档和解档，下面来看一下自定义类型的归档和解档操作，在开始的时候也说了，如果自定义的类型可以进行归档和解档的话，必须实现一个协议：NSCoding

不多说了，下面来直接看代码解释：

Person.h

 1 #import <Foundation/Foundation.h>
 2
 3 //类只有实现NSCoding协议才能归档
 4 @interface Person : NSObject<NSCoding>
 5
 6 @property(nonatomic,copy)NSString *name;
 7 @property(nonatomic,assign)NSInteger age;
 8 @property(nonatomic,retain)NSArray *apples;
 9
10 - (NSString *)description;
11
12 @end

这里自定义了一个Person类型，实现了NSCoding协议，然后他有三个属性，这里我们看到有新的方法去定义属性，这个后面说到内存管理的时候在详细说明。

Person.m

 1 #import "Person.h"
 2
 3 @implementation Person
 4
 5 //解归档的时候调用
 6 //也是一个初始化方法
 7 - (id)initWithCoder:(NSCoder *)aDecoder{
 8     NSLog(@"initWithCoder");
 9     self = [super init];
10     if(self != nil){
11         /*
12         _name = [aDecoder decodeObjectForKey:@"name"];
13         _age = [aDecoder decodeObjectForKey:@"age"];
14         _apples = [aDecoder decodeObjectForKey:@"apples"];
15          */
16         //一般我们将key定义成宏，这样就不会出错
17         _name = [[aDecoder decodeObjectForKey:@"name"] copy];
18         self.age = [aDecoder decodeObjectForKey:@"age"];
19         self.apples = [aDecoder decodeObjectForKey:@"apples"];
20
21     }
22     return self;
23 }
24
25 //归档时调用此方法
26 - (void)encodeWithCoder:(NSCoder *)aCoder{
27     NSLog(@"encodeWithCoder");
28     [aCoder encodeObject:_name forKey:@"name"];//一般key和属性名是取一样的
29     [aCoder encodeInteger:_age forKey:@"age"];
30     [aCoder encodeObject:_apples forKey:@"apples"];
31 }
32
33 - (NSString *)description{
34     NSString *string = [NSString stringWithFormat:@"name=%@,age=%d,apples=%@",_name,_age,_apples];
35     return string;
36 }
37
38 @end

在Person.m文件中，我们需要实现协议中的两个方法：

initWithCoder

encodeWithCoder

这两个方法一个是用于归档操作时会调用的方法，还有一个是用于解档操作时会调用的方法

1、解档的时候用到的方法

 1 - (id)initWithCoder:(NSCoder *)aDecoder{
 2     NSLog(@"initWithCoder");
 3     self = [super init];
 4     if(self != nil){
 5         /*
 6         _name = [aDecoder decodeObjectForKey:@"name"];
 7         _age = [aDecoder decodeObjectForKey:@"age"];
 8         _apples = [aDecoder decodeObjectForKey:@"apples"];
 9          */
10         //一般我们将key定义成宏，这样就不会出错
11         _name = [[aDecoder decodeObjectForKey:@"name"] copy];
12         self.age = [aDecoder decodeObjectForKey:@"age"];
13         self.apples = [aDecoder decodeObjectForKey:@"apples"];
14
15     }
16     return self;
17 }

这个是一个初始化的方法，同时他也是一个解档操作时会调用的方法，所以在这里我们既要写一下初始化方法的特定代码，还要写上解档的代码，这里主要看解档的代码

其实很简单，就是对属性重新写一下值，然后对每个属性指定一个key就可以了。这个有点类似于Android中的Parcel

(这里我们看到，在解档name属性的时候，用到了copy的一个方法，这个在后面会说到，有浅拷贝和深拷贝之分)

2、归档的时候用到的方法

1 //归档时调用此方法
2 - (void)encodeWithCoder:(NSCoder *)aCoder{
3     NSLog(@"encodeWithCoder");
4     [aCoder encodeObject:_name forKey:@"name"];//一般key和属性名是取一样的
5     [aCoder encodeInteger:_age forKey:@"age"];
6     [aCoder encodeObject:_apples forKey:@"apples"];
7 }

归档和解档的操作正好相反的，但是要注意的是：他们属性的key一定要保持一致

3、重写description方法

1 - (NSString *)description{
2     NSString *string = [NSString stringWithFormat:@"name=%@,age=%d,apples=%@",_name,_age,_apples];
3     return string;
4 }

在之前的文章中我说道过，我们在使用NSLog方法打印对象的值的时候，其实是调用对象的description方法，而这个方法是NSObject类中的，我们可以重写他，这样我们就可以打印我们想要的信息了。和Java中的toString方法一样。

下面就来看一下使用方法了

main.m

 1 #import <Foundation/Foundation.h>
 2
 3 #import "Person.h"
 4 int main(int argc, const charchar * argv[]) {
 5     @autoreleasepool {
 6
 7         Person *p = [[Person alloc] init];
 8         p.name = @"张三";
 9         p.age = 20;
10         p.apples = @[@"iphone",@"ipad"];
11
12         //归档
13         NSString *filePath = [NSHomeDirectory() stringByAppendingPathComponent:@"person.archiver"];
14         BOOL success = [NSKeyedArchiver archiveRootObject:p toFile:filePath];
15         if(success){
16             NSLog(@"归档成功");
17         }
18
19         //解归档
20         Person *person = [NSKeyedUnarchiver unarchiveObjectWithFile:filePath];
21         NSLog(@"%@",person);
22
23
24     }
25     return 0;
26 }

我们可以看到，使用起来是很简单的和上面的方式一样，运行结果：

 看到了，我们自定义的description方法，打印了我们自己想要的结果~~

时间： 2024-10-26 11:37:20

OC学习16——对象归档的相关文章

（转载）OC学习篇之---归档和解挡

前几篇文章说到了OC中的Foundation框架,今天我们来看一下OC中的一个重要知识点:归档 OC中的归档就是将对象写入到一个文件中,Java中的ObjectInputStream和ObjectOutputStream来进行操作的.当然在操作的这些对象都是需要实现一个接口:Serializable,同样的OC中操作的对象也是需要实现一个协议的,后面会说到. 一.已有类型的归档和解档 首先来看一个简单的例子: 1 // 2 // main.m 3 // 33_ObjectToFile 4 //

OC学习篇之---归档和解挡

前几篇文章说到了OC中的Foundation框架:http://blog.csdn.net/jiangwei0910410003/article/details/41852835,今天我们来看一下OC中的一个重要知识点:归档 OC中的归档就是将对象写入到一个文件中,Java中的ObjectInputStream和ObjectOutputStream来进行操作的.当然在操作的这些对象都是需要实现一个接口:Serializable,同样的OC中操作的对象也是需要实现一个协议的,后面会说到. 一.已有

ios学习笔记——对象归档

对象归档是一种序列化方式.为了便于数据传输,先将归档对象序列化为一个文件,然后再通过反归档将数据恢复到对象中. 归档技术可以实现数据的持久化,不过在大量数据和频繁读写的情况下,它就不太适合了. 对一个对象进行归档的条件是:改对象的类必须实现NSCoding协议,而且每个成员对象应该是基本数据类型或都是实现NSCoding协议的某个类的实例.

黑马程序员-OC学习日记-对象与方法、对象与函数

------- ios培训. android培训.java培训.期待与您交流! ---------- 一．NSString类简介 1.NSString是OC中用来表示字符串的一个类 2.NSString类创建 (1)通过字面量方式创建 NSString * str = @"要努力学习!"; (2)通过对象方法创建 NSString * str1 = [NSString alloc]; str1 = [str1 initWithUTF8String:"今天雾霾好大!"

oc学习之对象作为类的属性

对象做为类的属性 1. 一个Target中的类无法直接在另外1个Target中访问. 2. 类的属性代表什么? a. 类的属性代表这类事物具有的共同的特征 b. 类的属性代表这个类所拥有的东西. 灯: 属性: 形状 功率 价格  品牌 剩余寿命 方法: 照明. 音响: 方法: 发声音. 门: 属性: 尺寸 材料 颜色 价格 方法: 开 关 3. 类的方法代表什么? a. 代表这个类所具备的行为. 这个类所具备的功能. b. 一个类有什么方法 就去分析这个类有什么功能. 4. 属性的本质是变量.

【OC学习-16】动态VS静态类型识别？什么是动态绑定和动态加载？

动态VS静态 我们在实例化一个对象时,一般都是如下,就是静态类型: ASPerson * person=[[ASPerson alloc]init]; 还有一种是动态类型: id person=[[ASPerson alloc]init]; 可以看出来: (1)一般的带有明显类名(静态指针)的都是静态类型,而用id的通用指针的都是动态类型: (2)静态类型更容易阅读,更友好: (3)一般不涉及多态的时候,尽量用静态类型. 动态绑定和动态加载 这其实是针对类和对象说得,就是很多事情都不是事先弄好的

OC学习篇之---总结和学习目录

今天终于把OC的基础知识学习完了,但是这些知识只是最基础的,还有很多高级知识,这个可能需要后面慢慢的去学习才能体会到.下面就是这次学习OC的目录教程,如果大家发现有什么不正确的地方,请指正,小弟是新生,多请OC老鸟来喷~~ 1.OC学习篇之---概述 2.OC学习篇之---第一个程序HelloWorld 3.OC学习篇之---类的定义 4.OC学习篇之---类的初始化方法和点语法的使用 5.OC学习篇之---类的三大特性(封装,继承,多态) 6.OC学习篇之[email protected]关键

【OC学习-28】自定义对象的归档和解归档：例子说明以及简单总结

对对象进行归档,和对对象进行拷贝差不多路数,也就是需要协议,之前的时对NSString和NSNumber这些对象为什么没有归档协议?因为它们自带了. 所以如果我们要对自定义的对象(而不是Foundation里默认的对象)进行归档的话就需要引入归档协议<NSCoding>. 举例:声明一个User类,然后创建一个对象user1,把这个user1进行归档,然后把归档后的文件解归档到user2中,看看是否是原先的那些数据. (1)User.h #import <Foundation/Found

【OC学习-27】对象的归档以及解归档——标准数据和自定义数据的例子

对象归档?就是把对象的数据保存成文件实现数据的加密(即在文档中不是明文显示)和永久储存. 需要使用时,则从文件中恢复即可. (1)标准的数据 //main.m文件 #import <Foundation/Foundation.h> int main(int argc, const char * argv[]) { @autoreleasepool { //把一个数组进行归档 //创建一个文件路径 NSString *homePath=NSHomeDirectory(); NSString *f