对象的序列化存储：Serializable和Parceable

在进行Android开发的时候我们有时候需要用到数据的持久化存储，或者在进程之间传递数据。其中就可能需要用到对象的序列化，经过序列化的对象之后可以通过Intent或者Boundle来传输了。接下来还是想些介绍下吧。

创新互联秉承实现全网价值营销的理念，以专业定制企业官网，网站建设、成都网站设计，小程序开发，网页设计制作，成都做手机网站，成都全网营销帮助传统企业实现“互联网+”转型升级专业定制企业官网,公司注重人才、技术和管理，汇聚了一批优秀的互联网技术人才,对客户都以感恩的心态奉献自己的专业和所长。

1.什么叫序列化，什么叫反序列化

序列化： 将数据结构或对象转换成二进制串的过程。反序列化：将在序列化过程中所生成的二进制串转换成数据结构或者对象的过程。

简单来说，序列化就是将我们生成的对象进行存储起来(比如磁盘上)，以用来将来使用或者在网络上进行传输，而反序列化呢，就是由我们的之前序列化生成的二进制串重新生成对象的过程。注意，这里我们反复说的序列化啦，反序列化啦，都是针对的对象，而非类。因为我们是针对对象进行存取与传输的，而非类，当我们需要重新获取之前的对象的时候，是直接读取出来的(从文件或网络中)，而非根据类new出一个对象，这点是需要注意的。

2.如何序列化

序列话的方式有两种，一种是实现Serializable接口，一种是实现Parceable接口，下面会具体介绍这两种方式。

a.实现Serializable接口

这种序列化方式是Java提供的，它的优点是简单，其实Serializable接口是个空接口，因而我们并不需要实现什么抽象方法，但是我们却往往需要在类中声明一个静态变量标识(serialVersionUID)，但这不是必须的，我们不声明，依然可以实现序列化，但是这样的话会对反序列化产生一定的影响，可能会在我们对类做了修改之后而造成对象的反序列化失败。声明方式如下：

 
 
 
 
    
  
  
  
  
  1. private static final long serialVersionUID = 8711368828010083044L; 
    2.

注意，这里的值可以是任意值。

下面我们来具体实现下。

 
 
 
 
    
  
  
  
  
  1. package com.qc.admin.myserializableparceabledemo; 
    2. 
  
  
  
  
  2.  
    3. 
  
  
  
  
  3. import java.io.Serializable; 
    4. 
  
  
  
  
  4.  
    5. 
  
  
  
  
  5. /** 
    6. 
  
  
  
  
  6.  * Created by admin on 2016/12/1. 
    7. 
  
  
  
  
  7.  */ 
    8. 
  
  
  
  
  8.  
    9. 
  
  
  
  
  9. public class User implements Serializable { 
    10. 
  
  
  
  
  10.  
    11. 
  
  
  
  
  11.     private static final long serialVersionUID = 519067123721295773L; 
    12. 
  
  
  
  
  12.  
    13. 
  
  
  
  
  13.     public int userId; 
    14. 
  
  
  
  
  14.     public String userName; 
    15. 
  
  
  
  
  15.     public boolean isMale; 
    16. 
  
  
  
  
  16.  
    17. 
  
  
  
  
  17.     public User(int userId, String userName, boolean isMale) { 
    18. 
  
  
  
  
  18.  
    19. 
  
  
  
  
  19.         this.userId = userId; 
    20. 
  
  
  
  
  20.         this.userName = userName; 
    21. 
  
  
  
  
  21.         this.isMale = isMale; 
    22. 
  
  
  
  
  22.  
    23. 
  
  
  
  
  23.     } 
    24. 
  
  
  
  
  24.  
    25. 
  
  
  
  
  25.     @Override 
    26. 
  
  
  
  
  26.     public String toString() { 
    27. 
  
  
  
  
  27.         return "User{ " + 
    28. 
  
  
  
  
  28.                 "userId = " + userId + 
    29. 
  
  
  
  
  29.                 ", userName = " + userName + 
    30. 
  
  
  
  
  30.                 ", isMale = " + isMale + 
    31. 
  
  
  
  
  31.                 " }"; 
    32. 
  
  
  
  
  32.     } 
    33. 
  
  
  
  
  33. }  
    34.

下面是序列化与反序列化过程： 

 
 
 
 
    
  
  
  
  
  1. private void beginSerizable() throws IOException, ClassNotFoundException { 
    2. 
  
  
  
  
  2.  
    3. 
  
  
  
  
  3.         // 序列化 
    4. 
  
  
  
  
  4.         User user = new User(2016, "qian", true); 
    5. 
  
  
  
  
  5.         ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(new File(getFilesDir(), "myfile.txt"))); 
    6. 
  
  
  
  
  6.         out.writeObject(user); 
    7. 
  
  
  
  
  7.         out.close(); 
    8. 
  
  
  
  
  8.  
    9. 
  
  
  
  
  9.         // 反序列化 
    10. 
  
  
  
  
  10.         // 注意，这里后面的“/myfile.txt”前面有个斜杠“/”，否则会报“FileNotFoundException”异常 
    11. 
  
  
  
  
  11.         ObjectInputStream in = new ObjectInputStream(new FileInputStream(getFilesDir() + "/myfile.txt")); 
    12. 
  
  
  
  
  12.         User mUser = (User) in.readObject(); 
    13. 
  
  
  
  
  13.         textView.setText(mUser.toString()); 
    14. 
  
  
  
  
  14.         in.close(); 
    15. 
  
  
  
  
  15.         Log.i("test",mUser.toString()); 
    16. 
  
  
  
  
  16.     }  
    17.

运行结果截图： 

注意：如果是在Android项目中调用以上方法，别忘了在Manifest.xml文件中配置如下权限：

 
 
 
 
    
  
  
  
  
  1.  
    2. 
  
  
  
  
  2.   
    3.

b.实现Parceable接口

这种方式是Android提供的方式，相比较前面那种方式来讲，这种方式稍微有点复杂，我们需要自己尽享序列化与反序列化的操作，但是它却更加高效，并不需要执行大量的I/O操作。而且这种方式也是Android推荐的序列化方式，因此我们应该***Parceable。只要实现了这个接口，一个类的对象就可以实现序列化并可以通过Intent和Binder进行传递了。下面请看实例： 

 
 
 
 
    
  
  
  
  
  1. public class Book implements Parcelable { 
    2. 
  
  
  
  
  2.     public String bookTitle; 
    3. 
  
  
  
  
  3.     public int bookId; 
    4. 
  
  
  
  
  4.  
    5. 
  
  
  
  
  5.     protected Book(Parcel in) { 
    6. 
  
  
  
  
  6.         bookTitle = in.readString(); 
    7. 
  
  
  
  
  7.         bookId = in.readInt(); 
    8. 
  
  
  
  
  8.     } 
    9. 
  
  
  
  
  9.  
    10. 
  
  
  
  
  10.     public static final Creator CREATOR = new Creator() { 
    11. 
  
  
  
  
  11.         @Override 
    12. 
  
  
  
  
  12.         public Book createFromParcel(Parcel in) { 
    13. 
  
  
  
  
  13.             return new Book(in); 
    14. 
  
  
  
  
  14.         } 
    15. 
  
  
  
  
  15.  
    16. 
  
  
  
  
  16.         @Override 
    17. 
  
  
  
  
  17.         public Book[] newArray(int size) { 
    18. 
  
  
  
  
  18.             return new Book[size]; 
    19. 
  
  
  
  
  19.         } 
    20. 
  
  
  
  
  20.     }; 
    21. 
  
  
  
  
  21.  
    22. 
  
  
  
  
  22.     @Override 
    23. 
  
  
  
  
  23.     public int describeContents() { 
    24. 
  
  
  
  
  24.         return 0; 
    25. 
  
  
  
  
  25.     } 
    26. 
  
  
  
  
  26.  
    27. 
  
  
  
  
  27.     @Override 
    28. 
  
  
  
  
  28.     public void writeToParcel(Parcel parcel, int i) { 
    29. 
  
  
  
  
  29.         parcel.writeString(bookTitle); 
    30. 
  
  
  
  
  30.         parcel.writeInt(bookId); 
    31. 
  
  
  
  
  31.     } 
    32. 
  
  
  
  
  32. }  
    33.

这里将Book这个类就实现了Parcelable接口，其实在Android Studio IDE中，上述过程很简单，我们只需要定义一个类，实现Parcelable接口，然后在里面定义我们的属性或者说是字段，根据提示的错误，按照它提示的方法覆盖相应的方法，之后的一切其实都可以自动生成(不过如果需要构造方法的话，那就需要自动生成了，toString()方法也是自己实现的)，所以不用担心在Android开发中通过实现Parceable接口会比较麻烦，因为AS都会为你自动生成。上面我们已经完整的将Book类实现了Parceable接口，那接下来如何序列化和反序列化呢?如果你说，刚才不是已经说过了吗，采用文件读取的方式不久可以了啦...当你那样做的时候，你会发现会报如下的错误： 

Why???...什么情况?提示我们Book类没有实现序列化：

 
 
 
 
    
  
  
  
  
  1. /System.err: java.io.NotSerializableException: com.qc.admin.myserializableparceabledemo.Book 
    2.

好啦，之所以出现这种问题，并不是我们的实现过程有问题，而是使用该类的方式行不通。到这里我们就明白了Serializable和Parceable两种方式实现序列化还是有区别的，刚才我们也讲了，Parceable更加高效，不会像Serializable那样有大量的I/O操作，这句话的具体含义就道出了Serializable与Parcelable区别：虽然两者都是用于支持序列化、反序列化话操作，但是两者***的区别在于存储媒介的不同，Serializable是将序列化后的对象存储在硬盘上，使用I/O读写的方式，而Parcelable是将其存储在内存中，是针对内存的读写，熟悉计算机组成原理的朋友都知道，内存的读写速度显然要远远大于I/O的读写速度，这也是为什么Android中推荐使用Parcelable这种方式来实现对象的序列化。

那我们应该怎么使用通过实现Parcelable接口实现序列化的对象呢?答案是：通过Intent方式传递，除了基本类型外，Intent只能传输序列化之后的对象，对应这两种序列化方式，也有两种相应的方法：

 
 
 
 
    
  
  
  
  
  1. mIntent.getSerializableExtra(string name );  
    2. 
 
 
 
 
 
 
 
 
    
  
  
  
  
  1. mIntent.getParcelableExtra(String name ); 
    2.

当然，放入的操作就没有这种区分了，都是方法：

 
 
 
 
    
  
  
  
  
  1. mIntent.putExtra(); 
    2.

我们可以在***个Activity中将序列化对象放入Intent，在另一个Activity中取出，比如：在另一端获取对象，例如: 

 
 
 
 
    
  
  
  
  
  1. Bundle mBundle = getIntent().getExtras(); 
    2. 
  
  
  
  
  2. Book mBook = mBundle.getParcelable("book1");  
    3.

下面再看类User实现Parceable接口的过程，它内部包含了一个可序列化的类Book，具体细节跟上面的有点不同：

 
 
 
 
    
  
  
  
  
  1. package com.qc.admin.myserializableparceabledemo; 
    2. 
  
  
  
  
  2.  
    3. 
  
  
  
  
  3. import android.os.Parcel; 
    4. 
  
  
  
  
  4. import android.os.Parcelable; 
    5. 
  
  
  
  
  5.  
    6. 
  
  
  
  
  6. /** 
    7. 
  
  
  
  
  7.  * Created by admin on 2016/12/1. 
    8. 
  
  
  
  
  8.  */ 
    9. 
  
  
  
  
  9.  
    10. 
  
  
  
  
  10. public class User implements Parcelable { 
    11. 
  
  
  
  
  11.  
    12. 
  
  
  
  
  12.     public int userId; 
    13. 
  
  
  
  
  13.     public String userName; 
    14. 
  
  
  
  
  14.     public boolean isMale; 
    15. 
  
  
  
  
  15.     public Book book; 
    16. 
  
  
  
  
  16.  
    17. 
  
  
  
  
  17.  
    18. 
  
  
  
  
  18.     public User(int userId, String userName, boolean isMale, Book book) { 
    19. 
  
  
  
  
  19.  
    20. 
  
  
  
  
  20.         this.userId = userId; 
    21. 
  
  
  
  
  21.         this.userName = userName; 
    22. 
  
  
  
  
  22.         this.isMale = isMale; 
    23. 
  
  
  
  
  23.         this.book = book; 
    24. 
  
  
  
  
  24.     } 
    25. 
  
  
  
  
  25.  
    26. 
  
  
  
  
  26.  
    27. 
  
  
  
  
  27.     protected User(Parcel in) { 
    28. 
  
  
  
  
  28.         userId = in.readInt(); 
    29. 
  
  
  
  
  29.         userName = in.readString(); 
    30. 
  
  
  
  
  30.         isMale = in.readByte() != 0; 
    31. 
  
  
  
  
  31.         // 此为不同之处1 
    32. 
  
  
  
  
  32.         // 也可以通过这种方式：book = in.readParcelable(Thread.currentThread().getContextClassLoader()); 
    33. 
  
  
  
  
  33.         book = in.readParcelable(Book.class.getClassLoader()); 
    34. 
  
  
  
  
  34.          
    35. 
  
  
  
  
  35.     } 
    36. 
  
  
  
  
  36.  
    37. 
  
  
  
  
  37.     public static final Creator CREATOR = new Creator() { 
    38. 
  
  
  
  
  38.         @Override 
    39. 
  
  
  
  
  39.         public User createFromParcel(Parcel in) { 
    40. 
  
  
  
  
  40.             return new User(in); 
    41. 
  
  
  
  
  41.         } 
    42. 
  
  
  
  
  42.  
    43. 
  
  
  
  
  43.         @Override 
    44. 
  
  
  
  
  44.         public User[] newArray(int size) { 
    45. 
  
  
  
  
  45.             return new User[size]; 
    46. 
  
  
  
  
  46.         } 
    47. 
  
  
  
  
  47.     }; 
    48. 
  
  
  
  
  48.  
    49. 
  
  
  
  
  49.  
    50. 
  
  
  
  
  50.     // 几乎在所有的情况下都应该返回0，只有在当前对象中存在文件描述的时候，此方法返回CONTENTS_FILE_DESCRIPTOR（常量值为1） 
    51. 
  
  
  
  
  51.     @Override 
    52. 
  
  
  
  
  52.     public int describeContents() { 
    53. 
  
  
  
  
  53.         return 0; 
    54. 
  
  
  
  
  54.     } 
    55. 
  
  
  
  
  55.  
    56. 
  
  
  
  
  56.     // 将对象写入序列化结构中，其中i标识有两种值，0或者1（PARCELABLE_WRITE_RETURN_VALUE） 
    57. 
  
  
  
  
  57.     // 为1时表示当前对象需要作为返回值返回，不能立即释放资源，几乎所有情况都为0 
    58. 
  
  
  
  
  58.     @Override 
    59. 
  
  
  
  
  59.     public void writeToParcel(Parcel parcel, int i) { 
    60. 
  
  
  
  
  60.         parcel.writeInt(userId); 
    61. 
  
  
  
  
  61.         parcel.writeString(userName); 
    62. 
  
  
  
  
  62.         // 注意这里，并不是直接写入boolean值，而是写入整数值 
    63. 
  
  
  
  
  63.         parcel.writeByte((byte) (isMale ? 1 : 0)); 
    64. 
  
  
  
  
  64.         // 此为不同之处2 
    65. 
  
  
  
  
  65.         parcel.writeParcelable(book, i); 
    66. 
  
  
  
  
  66.     } 
    67. 
  
  
  
  
  67.  
    68. 
  
  
  
  
  68.     @Override 
    69. 
  
  
  
  
  69.     public String toString() { 
    70. 
  
  
  
  
  70.         return "User{ " + 
    71. 
  
  
  
  
  71.                 "userId = " + userId + 
    72. 
  
  
  
  
  72.                 ", userName = " + userName + 
    73. 
  
  
  
  
  73.                 ", isMale = " + isMale + 
    74. 
  
  
  
  
  74.                 "book = " + book.toString() + 
    75. 
  
  
  
  
  75.                 " }"; 
    76. 
  
  
  
  
  76.     } 
    77. 
  
  
  
  
  77.  
    78. 
  
  
  
  
  78. }  
    79.

可以看出，结果已经正确的打印了出来了： 

注意：在 Parcelable 中，我们无法直接写入 boolean 值，而是将其转化为整数值进行保存，这里为 Byte，当然，你也可以使用 Int 等。

网页标题：对象的序列化存储：Serializable和Parceable
分享路径：http://www.shufengxianlan.com/qtweb/news40/185740.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

外贸网站建设知识

分类信息网站

app开发公司　　 　网络口碑营销　　 　成都免费做网站公司　　 　成都网站建设　　 　app软件开发公司　　 　绵阳梓潼做网站　　 　吉安网站建设　　 　外贸网站建设　　 　电商网站建设　　 　移动服务器托管　　 　成都网站设计　　 　普能电气　　 　成都广告设计公司　　 　成都展柜定制　　 　成都h5建站开发　　 　成都网站推广　　 　禾巨建站　　 　响应式网站设计　　 　微信网站开发　　 　成都小程序开发