Android中Intent传递对象的两种方法Serializable,Parcelable
作者：呼啸
字体：[ ] 类型：转载 时间：
这篇文章主要介绍了Android中的传递有两个方法，一个是Serializable，另一个是Parcelable，对intent传递对象的两种方法感兴趣的朋友一起学习吧
Android中的传递有两个方法，一个是Serializable，另一个是Parcelable。
Serializable是J2SE本身就支持的。而Parcelable是Android所特有的。
二者的使用场景和区别：
1）在使用内存的时候，Parcelable比Serializable性能高，所以推荐使用Parcelable。
2）Serializable在序列化的时候会产生大量的临时变量，从而引起频繁的GC。
3）Parcelable不能使用在要将数据存储在磁盘上的情况，因为Parcelable不能很好的保证数据的持续性在外界有变化的情况下。尽管Serializable效率低点，但此时还是建议使用Serializable 。
Serializable接口实现比较简单，只要实现setter和getter，就可以了。
而Parcelable实现比较麻烦些。用一个小的demo来说明：
1.新建android项目ObjectTranDemo
2.创建一个entity的javaBean:Person.java.实现Serializable接口
package com.example.
import java.io.S
public class Person implements Serializable {
private static final long serialVersionUID = -0464481L;
public String getName() {
public void setName(String name) {
this.name =
public int getAge() {
public void setAge(int age) {
this.age =
3.创建主界面activity_main.xml:
&?xml version="1.0" encoding="utf-8"?&
&LinearLayout xmlns:android="/apk/res/android"
android:orientation="vertical"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:text="android object trance"
android:id="@+id/button1"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:text="Serializable"
android:id="@+id/button2"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:text="Parcelable"
&/LinearLayout&
4.创建主activity。这个activity主要用来响应点击事件，和传递数据。ObjecttranDemo.java:
package com.example.
import android.app.A
import android.content.I
import android.os.B
import android.view.V
import android.view.View.OnClickL
import android.widget.B
public class ObjectTranDemo extends Activity implements OnClickListener{
private Button sButton,pB
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
setupViews();
//initial the views
public void setupViews(){
sButton = (Button)findViewById(R.id.button1);
pButton = (Button)findViewById(R.id.button2);
sButton.setOnClickListener(this);
pButton.setOnClickListener(this);
//Serializeable object trance
public void SerializeMethod(){
Person mPerson = new Person();
mPerson.setName("durant");
mPerson.setAge(25);
Intent mIntent = new Intent(this,ObjectTranDemo1.class);
Bundle mBundle = new Bundle();
mBundle.putSerializable("mPerson",mPerson);
mIntent.putExtras(mBundle);
startActivity(mIntent);
//Pacelable object trance
public void PacelableMethod(){
Book mBook = new Book();
mBook.setBookName("a man from mars");
mBook.setAuthor("james");
mBook.setPublishTime(2014);
Intent mIntent = new Intent(this,ObjectTranDemo2.class);
Bundle mBundle = new Bundle();
mBundle.putParcelable("mBook", mBook);
mIntent.putExtras(mBundle);
startActivity(mIntent);
public void onClick(View v) {
if(v == sButton){
SerializeMethod();
PacelableMethod();
5.新建activity ObjectTranDemo1.java用来显示Serializable接口传递过来的数据
package com.example.
import android.app.A
import android.os.B
import android.widget.TextV
public class ObjectTranDemo1 extends Activity{
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
TextView mTextView = new TextView(this);
Person mPerson = (Person)getIntent().getSerializableExtra("mPerson");
mTextView.setText("You name is: " + mPerson.getName() + "\n"+
"You age is: " + mPerson.getAge());
setContentView(mTextView);
至此，Serializable接口传递数据完毕，对了，别忘了，在Mainfest.xml文件中声明新的activity
&?xml version="1.0" encoding="utf-8"?&
&manifest xmlns:android="/apk/res/android"
package="com.example.objecttrandemo"
android:versionCode="1"
android:versionName="1.0" &
android:minSdkVersion="8"
android:targetSdkVersion="18" /&
&application
android:allowBackup="true"
android:icon="@drawable/ic_launcher"
android:label="@string/app_name"
android:theme="@style/AppTheme" &
android:name="com.example.objecttrandemo.ObjectTranDemo"
android:label="@string/app_name" &
&intent-filter&
&action android:name="android.intent.action.MAIN" /&
&category android:name="android.intent.category.LAUNCHER" /&
&/intent-filter&
&/activity&
&activity android:name=".ObjectTranDemo1"&&/activity&
&activity android:name=".ObjectTranDemo2"&&/activity&
&/application&
&/manifest&
下面看Parcelable的传递：
实现Parcelable一般需要4个步骤：
1）implements Parcelable
2）重写writeToParcel方法，将你的对象序列化为一个Parcel对象，即：将类的数据写入外部提供的Parcel中，打包需要传递的数据到Parcel容器保存，以便从 Parcel容器获取数据
3）重写describeContents方法，内容接口描述，默认返回0就可以
4）实例化静态内部对象CREATOR实现接口Parcelable.Creator
public static final Parcelable.Creator&T& CREATOR
注：其中public static final一个都不能少，内部对象CREATOR的名称也不能改变，必须全部大写。需重写本接口中的两个方法：createFromParcel(Parcel in) 实现从Parcel容器中读取传递数据值，封装成Parcelable对象返回逻辑层，newArray(int size) 创建一个类型为T，长度为size的数组，仅一句话即可（return new T[size]），供外部类反序列化本类数组使用。
简而言之：通过writeToParcel将你的对象映射成Parcel对象，再通过createFromParcel将Parcel对象映射成你的对象。也可以将Parcel看成是一个流，通过writeToParcel把对象写到流里面，在通过createFromParcel从流里读取对象，只不过这个过程需要你来实现，因此写的顺序和读的顺序必须一致。
1.新建Book的实体类：
Book.java:
package com.example.
import android.os.P
import android.os.P
public class Book implements Parcelable{
private String bookN
private int publishT
public String getBookName() {
return bookN
public void setBookName(String bookName) {
this.bookName = bookN
public String getAuthor() {
public void setAuthor(String author) {
this.author =
public int getPublishTime() {
return publishT
public void setPublishTime(int publishTime) {
this.publishTime = publishT
//Internal Description Interface,You do not need to manage
public int describeContents() {
//give some attention to the oder betwwen writeToParcel and createFromParcel
public void writeToParcel(Parcel parcel, int flags){
parcel.writeString(bookName);
parcel.writeString(author);
parcel.writeInt(publishTime);
public static final Parcelable.Creator&Book& CREATOR = new Creator&Book&() {
public Book[] newArray(int size) {
return new Book[size];
public Book createFromParcel(Parcel source) {
Book mBook = new Book();
mBook.bookName = source.readString();
mBook.author = source.readString();
mBook.publishTime = source.readInt();
2.新建activity :ObjectTranDemo2.java.用来显示parcelable的数据：
package com.example.
import android.app.A
import android.os.B
import android.widget.TextV
public class ObjectTranDemo2 extends Activity{
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
TextView mTextView = new TextView(this);
Book mBook = (Book)getIntent().getParcelableExtra("mBook");
mTextView.setText("Book name is: " + mBook.getBookName()+"\n"+
"Author is: " + mBook.getAuthor() + "\n" +
"PublishTime is: " + mBook.getPublishTime());
setContentView(mTextView);
在上篇文章给大家介绍了，，感兴趣的朋友可以点击了解详情。
您可能感兴趣的文章:
大家感兴趣的内容
12345678910
最近更新的内容
常用在线小工具2329人阅读
android（3）
在Activity或者组件之前传递信息时，一般采用intent绑定bundle的方式传值，在使用过程中需要注意的是不要用bundle传递大容量数据：
& & & &在做项目的过程中，发现使用bundle在两个Activity之间传递数据的时候，有时候第二个Activity根本就显示不出来，刚开始以为是第二个Activity的布局出了问题，可怎么调整也发现解决不了问题，然后注释掉了一个往bundle里put数据的代码，发现立即正常了，经过分析发现是由于bundle不能传递大容量的数据信息，在stackoverflow里面查阅发现有同行遇到类似的问题：
（1）“The size limit of Intent is still pretty low in&Jelly Bean, which is somewhat lower than 1MB (around 90K), so you should always be cautious about your data length, even if your application targets only latest Android versions.”
（2）“As per my experience (sometime ago), you are able to put up to&1MB&of data in a&Bundleencapsulated inside&Intent. I think, this restriction was valid up till&Froyo&or&GingerBread.”
& & & &所以在通过bundle传递数据时只能传递较小的数据信息，对于在不同组件之间需要传递大容量数据的情况时，有几种替代方式可以解决不能用bundle传递这些数据的问题：
方法一：将需要传递的数据写在临时文件或者数据库中，再跳转到另外一个组件的时候再去读取这些数据信息，这种处理方式会由于读写文件较为耗时导致程序运行效率较低；
方法二：将需要传递的数据信息封装在一个静态的类中（注意当前组件和要跳转到的组件必须属于同一个进程，因为进程之间才能够共享数据），在当前组件中为类设置内容，然后再跳转到的组件中去取，这种处理方式效率很高，但是会破坏程序的独立性。
& & & 具体采用哪种替代方式取决于具体的情况，我比较喜欢采取第二种处理方式，因为这样会大大提高程序的运行效率，至于程序的独立性，看你怎么去封装这个类了。
&&相关文章推荐
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：38947次
排名：千里之外
转载：16篇
(2)(2)(1)(1)(1)(1)(1)(3)(9)(3)(1)原创文章，转载请注明出处：&&&&&&&&&&&&&&&&&&&&&&
Android开发中，我们经常用到JavaBean类以及序列化的知识，但经常用并不代表能够深入理解，
今天我希望来总结一下JavaBean类和序列化知识，以便让自己理解的更加深入。
首先说一下JavaBean类，我们在Android开发中对JavaBean类的概念没有非常严格，在JSP开发中，Bean类
有相对严格的规范，这里http://wiki.netbeans.org/NetBeansJavaBeansTutorial，是Wiki上SUN公司的
一些定义，比如一些命名的规则，必须有一个空的构造方法等等规定，有些Bean类的规范还要求必须实现序列
化。但我们在Java开发中使用到的Bean类并没有那么严格，这是因为用途不同。我们在Android开发中使用Bean
类最多的场景是从网络获取数据，将数据以Bean类组织，Bean类中的数据用于填充UI界面中的控件。此处使用
Bean类主要是组织数据方便，便于将其中的数据填充到控件中。
再说一下序列化，序列化的作用是①将对象的状态保存在存储媒体中以便可以在以后重新创建出完全相同的副本；
②按值将对象从一个应用程序域发送至另一个应用程序域或者进行网络传输。
Android中的对象序列化的过程是将对象转化为字节数组，反序列化就是将字节数组重新恢复成对象。
我们在Android开发中，一般在Bundle，intent传递Bean类对象（或包含Bean类的集合）时，需要进行序列化；
在IPC机制中也用到了Bean类的序列化。注意，传递的Bean类对象，并不是原对象本身，而是原对象的复制，
两者的地址不一样，但其他值是一样的。当在不同Activity见传递对象时，因为不是传递的原对象的引用，从而
避免了内存泄漏。
我们再用通俗一些的语言说一下序列化的作用：
①就是将对象的状态保存在磁盘上，当程序不运行时，该状态不消失，下次程序运行时读取该状态，恢复对象，
更直白一些，就是保存。当然保存的方法有很多很多种，这个只是一种，且主要针对实体类；
②在Activity之间，Activity和Fragment之间，进程间，传递对象，或者网络传递对象，这个时候传递的是序
列化后的Byte数组，也就是方便传输，不易出错，不同程序间兼容性更好；
可看到有人这样理解序列化的作用：
也就是换个时间，换个地点使用对象信息
换个时间，就是先将对象信息存盘，等需要的时候再次读取，说的是同一个Activity或者Fragment对Bean类信息的使用；
换个地点，也就是不同Activity或者Fragment，或者不同进程，甚至不同程序对Bean类信息的使用。
两种序列化的区别：
①实现Serializable接口由JavaSE支持，而实现Parcelable接口是Android特有的。实现Parcelable比实现Serializable
效率高，但用法稍微复杂；
②实现Serializable接口，只需要我们标记一下，系统自动将对象序列化；实现Parcelable接口，还需要实例化静态内部
变量CREATOR，需要我们操作辅助实现序列化；
③在使用内存的时候，Parcelable的性能比Serializable好，在内存开销方面较小，所以在内存间数据传输时推荐使用Parcelable，如activity间传输数据；
④在永久化保存对象的时候，Serializable可以实现，所以在需要保存或网络传输数据时选择Serializable。
Parcelable不能用在需要将对象存储在磁盘的情况下，且因为android不同版本Parcelable可能不同，所以不推荐使用Parcelable进行数据持久化；
⑤Serializable在序列化的时候会产生大量的临时变量，从而引起频繁的GC，影响效率；
本篇文章没有叙述严格定义，其中的严格概念今后会在的文章中具体阐明。
阅读(...) 评论()4470人阅读
Android高手之路（6）
注：本文改编自的文章，原文地址：
Android中的传递有两个方法，一个是Serializable，另一个是Parcelable。
Serializable是J2SE本身就支持的。而Parcelable是Android所特有的。
二者的使用场景和区别：
1）在使用内存的时候，Parcelable比Serializable性能高，所以推荐使用Parcelable。
2）Serializable在序列化的时候会产生大量的临时变量，从而引起频繁的GC。
3）Parcelable不能使用在要将数据存储在磁盘上的情况，因为Parcelable不能很好的保证数据的持续性在外界有变化的情况下。尽管Serializable效率低点，但此时还是建议使用Serializable 。
Serializable接口实现比较简单，只要实现setter和getter，就可以了。
而Parcelable实现比较麻烦些。用一个小的demo来说明：
1.新建android项目ObjectTranDemo
2.创建一个entity的javaBean:Person.java.实现Serializable接口
package com.example.
import java.io.S
public class Person implements Serializable {
private static final long serialVersionUID = -0464481L;
public String getName() {
public void setName(String name) {
this.name =
public int getAge() {
public void setAge(int age) {
this.age =
3.创建主界面activity_main.xml:
&?xml version=&1.0& encoding=&utf-8&?&
&LinearLayout xmlns:android=&/apk/res/android&
android:orientation=&vertical&
android:layout_width=&fill_parent&
android:layout_height=&fill_parent&
android:layout_width=&fill_parent&
android:layout_height=&wrap_content&
android:text=&android object trance&
android:id=&@+id/button1&
android:layout_width=&fill_parent&
android:layout_height=&wrap_content&
android:text=&Serializable&
android:id=&@+id/button2&
android:layout_width=&fill_parent&
android:layout_height=&wrap_content&
android:text=&Parcelable&
&/LinearLayout&
4.创建主activity。这个activity主要用来响应点击事件，和传递数据。ObjecttranDemo.java:
package com.example.
import android.app.A
import android.content.I
import android.os.B
import android.view.V
import android.view.View.OnClickL
import android.widget.B
public class ObjectTranDemo extends Activity implements OnClickListener{
private Button sButton,pB
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
setupViews();
//initial the views
public void setupViews(){
sButton = (Button)findViewById(R.id.button1);
pButton = (Button)findViewById(R.id.button2);
sButton.setOnClickListener(this);
pButton.setOnClickListener(this);
//Serializeable object trance
public void SerializeMethod(){
Person mPerson = new Person();
mPerson.setName(&durant&);
mPerson.setAge(25);
Intent mIntent = new Intent(this,ObjectTranDemo1.class);
Bundle mBundle = new Bundle();
mBundle.putSerializable(&mPerson&,mPerson);
mIntent.putExtras(mBundle);
startActivity(mIntent);
//Pacelable object trance
public void PacelableMethod(){
Book mBook = new Book();
mBook.setBookName(&a man from mars&);
mBook.setAuthor(&james&);
mBook.setPublishTime(2014);
Intent mIntent = new Intent(this,ObjectTranDemo2.class);
Bundle mBundle = new Bundle();
mBundle.putParcelable(&mBook&, mBook);
mIntent.putExtras(mBundle);
startActivity(mIntent);
public void onClick(View v) {
if(v == sButton){
SerializeMethod();
PacelableMethod();
5.新建activity &&ObjectTranDemo1.java用来显示Serializable接口传递过来的数据
package com.example.
import android.app.A
import android.os.B
import android.widget.TextV
public class ObjectTranDemo1 extends Activity{
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
TextView mTextView = new TextView(this);
Person mPerson = (Person)getIntent().getSerializableExtra(&mPerson&);
mTextView.setText(&You name is: & + mPerson.getName() + &\n&+
&You age is: & + mPerson.getAge());
setContentView(mTextView);
至此，Serializable接口传递数据完毕，对了，别忘了，在Mainfest.xml文件中声明新的activity
&?xml version=&1.0& encoding=&utf-8&?&
&manifest xmlns:android=&/apk/res/android&
package=&com.example.objecttrandemo&
android:versionCode=&1&
android:versionName=&1.0& &
android:minSdkVersion=&8&
android:targetSdkVersion=&18& /&
&application
android:allowBackup=&true&
android:icon=&@drawable/ic_launcher&
android:label=&@string/app_name&
android:theme=&@style/AppTheme& &
android:name=&com.example.objecttrandemo.ObjectTranDemo&
android:label=&@string/app_name& &
&intent-filter&
&action android:name=&android.intent.action.MAIN& /&
&category android:name=&android.intent.category.LAUNCHER& /&
&/intent-filter&
&/activity&
&activity android:name=&.ObjectTranDemo1&&&/activity&
&activity android:name=&.ObjectTranDemo2&&&/activity&
&/application&
&/manifest&
下面看Parcelable的传递：
实现Parcelable一般需要4个步骤：
1）implements Parcelable
2）重写writeToParcel方法，将你的对象序列化为一个Parcel对象，即：将类的数据写入外部提供的Parcel中，打包需要传递的数据到Parcel容器保存，以便从 Parcel容器获取数据
3）重写describeContents方法，内容接口描述，默认返回0就可以
4）实例化静态内部对象CREATOR实现接口Parcelable.Creator
public static final Parcelable.Creator&T& CREATOR
注：其中public static final一个都不能少，内部对象CREATOR的名称也不能改变，必须全部大写。需重写本接口中的两个方法：createFromParcel(Parcel in) 实现从Parcel容器中读取传递数据值，封装成Parcelable对象返回逻辑层，newArray(int size) 创建一个类型为T，长度为size的数组，仅一句话即可（return new T[size]），供外部类反序列化本类数组使用。
简而言之：通过writeToParcel将你的对象映射成Parcel对象，再通过createFromParcel将Parcel对象映射成你的对象。也可以将Parcel看成是一个流，通过writeToParcel把对象写到流里面，在通过createFromParcel从流里读取对象，只不过这个过程需要你来实现，因此写的顺序和读的顺序必须一致。
1.新建Book的实体类：
Book.java:
package com.example.
import android.os.P
import android.os.P
public class Book implements Parcelable{
private String bookN
private int publishT
public String getBookName() {
return bookN
public void setBookName(String bookName) {
this.bookName = bookN
public String getAuthor() {
public void setAuthor(String author) {
this.author =
public int getPublishTime() {
return publishT
public void setPublishTime(int publishTime) {
this.publishTime = publishT
//Internal Description Interface,You do not need to manage
public int describeContents() {
//give some attention to the oder betwwen
writeToParcel and createFromParcel
public void writeToParcel(Parcel parcel, int flags){
parcel.writeString(bookName);
parcel.writeString(author);
parcel.writeInt(publishTime);
public static final Parcelable.Creator&Book& CREATOR = new Creator&Book&() {
public Book[] newArray(int size) {
return new Book[size];
public Book createFromParcel(Parcel source) {
Book mBook = new Book();
mBook.bookName = source.readString();
mBook.author = source.readString();
mBook.publishTime = source.readInt();
2.新建activity :ObjectTranDemo2.java.用来显示parcelable的数据：
package com.example.
import android.app.A
import android.os.B
import android.widget.TextV
public class ObjectTranDemo2 extends Activity{
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
TextView mTextView = new TextView(this);
Book mBook = (Book)getIntent().getParcelableExtra(&mBook&);
mTextView.setText(&Book name is: & + mBook.getBookName()+&\n&+
&Author is: & + mBook.getAuthor() + &\n& +
&PublishTime is: & + mBook.getPublishTime());
setContentView(mTextView);
&&相关文章推荐
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：1024755次
积分：14406
积分：14406
排名：第1020名
原创：500篇
转载：51篇
评论：155条
(1)(4)(4)(1)(1)(2)(1)(4)(2)(2)(1)(2)(7)(3)(1)(1)(1)(2)(6)(2)(6)(5)(7)(7)(16)(2)(17)(10)(16)(12)(14)(13)(9)(15)(15)(15)(23)(25)(30)(6)(1)(24)(49)(33)(22)(30)(22)(10)(9)(12)(13)(2)(1)(2)(1)(3)(1)(3)(4)1272人阅读
Android基础之Activity（2）
学习android已有时日，但是旧时的知识都好似遗忘了，所以想通过写技术博客来温习知识。孔子曰：“温故而知新，可以为师矣”。鄙人第一次写博客，文笔也不是很好，如若有表述不清，技术点有错误之处，还望各路大神们指点迷津，小弟在此谢过!
寄望：1.写博客当然希望有人看啦~\(≧▽≦)/~啦啦啦，不过没人看也不打紧啦，我也会坚持每天温习和更新自己所学的知识点，我想往实际操作细节方面写，因为当初我学习的时候，很多小小的细节就把我卡住了，浪费好多时间，希望正走在路上的朋友们都能少走点弯路，共同进步。
2.第二个希望通过写博客增强自己的文字表述能力，最好能形成自己的知识体系那就更好啦！O(∩_∩)O哈哈~
3.希望自己能够养成坚持不懈努力的习惯，从坚持写博客到生活的方方面面都能够养成良好的习惯。既然内心已经做出了最重要的选择，那就付出所有激情和热血去开创自己的路吧！
Activity间的数据传递
Intent：（数据传递的灵魂）
Android的应用程序包含三种重要组件：Activity、Service、BroadcastReceiver，应用程序采用一致的方式来启动他们——都是依靠Intent来启动的，Intent封装了程序想要启动的程序的意图。
Intent意图:分隐式意图和显示意图，具体详细知识可以查看视频：
我给出一个基础的视频链接，极客学院的，个人觉得讲得很详细，不过需要注册登录成为会员才能观看：
/course/681.html
Intent启动Activity的两种方式：startActivity（Intent
intent）和 startActivityForResult（Intent intent，int requestCode）
1.使用Intent携带数据
创建两个Activity， FirstActivity和SecondActivity，从FirstActivity中传递数据到SecondActivty中，如下：
在FirstActivity中书写代码传递数据出去：
&span style=&font-size:14&&String data = &Hello SecondActivity&;
Intent intent = new Intent(FirstActivity.this,SecondActivity.class);
intent.putExtra(&key&,data);//key是取数据时需要用到的键，相当于一把钥匙
startActivity(intent);//启动下一个Activity&/span&
在SecondActivity中接收数据：
&span style=&font-size:14&&Intent intent = getIntent();//记住接收数据时是使用 getIntent（）方法获得intent对象
String data = intent.getStringExtra(&key&);//通过key取值（即传递数据时候用到的键，相应的，取值时，要传入对应的key）
Log.i(&SecondActivity&,data);//通过日志打印出获取到的数据&/span&
2.使用Bundle包装数据
创建Bundle对象，然后把需要传递的数据都保存在Bundle对象中，然后再将Bundle对象存放在Intent里。到了指定Activity后，先从Intent取出Bundle,再从Bundle中将数据一一取出。
使用bundle&传递数据&步骤：
&（1）先创建一个Bundle的对象
& & & & & &Intent intent = new Intent();
& & & & & &Bundle bundle = new Bundle();
& & & & & & & & & &bundle.putString(&name&, &阿花&);
& & & & & & & & & &bundle.putString(&sex&, &女&);
& & & & & & & & & &bundle.putInt(&age&, 18);
& （2）将Bundle对象放在Intent对象中
& & & & & & & & & &intent.putExtra(&bundle&,
& （3）启动Activity
& & & & & & & & & &startActivity(intent&);
接收数据：
Bundle取值& & & & & & & & & & & & & & & & & & & & &
& & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & &Inten
&span style=&font-size:14&&
Bundle bundle = intent.getBundleExtra(&bundle&); //bundle对象中是以一个数组的形式存放数据
String name = bundle.getString(&name&);
String sex = bundle.getString(&sex);
int age = bundle.getInt(&age&);&/span&
3.序列化对象Seriazable
首先创建一个Person类，让Person类实现Serializable接口。Person类中有name，sex，age三个属性，实现Person类的
get 、set 方法。（！注意:该对象的类必需实现Serializable接口）
把要传递到下一个Activity的数据存放在Person类的对象中，启动Activity把数据传递出去 & &Intent i = new Intent();&/span&Person p = new Person();
p.setName(&钱多多&);//通过set方法把数据存到Person类对象p中
p.setSex(&男&);
p.setAge(22);
i.putExtra(&key&, p); //向Intent对象中存入Person对象P
startActivity(i);
在另一个Activity中取传递过来的对象数据：
Intent i = new Intent();&/span&
Serializable p = i.getSerializableExtra(&key&); //反序列化数据对象
if (p instanceof Person) {
Person person = (Person) //获取到携带数据的Person对象p&/span&tv.setText(&name:&+ person.getName()）；//使用数据,把数据展示在TextView上
4.Application传值（不常用）
创建一个类MyApplication&，该类要继承与Application。
& & 1.创建一个Application的类 ：MyApplication&
& & 2.获得AppLication的对象
& & & & &MyApplication application = (MyApplication) MainActivity.this.getApplication();
& & 3.给MyApplication对象赋值
& & & & &application.setData(&abc&);
取值：
& & & &MyApplication application = (MyApplication) getApplication();
& & & & String data = application.getData();
5.Parcelable（最常用，传递数据效率更高）
（1）实现序列化的方法
Android中实现序列化有两个选择：一是实现Serializable接口（是JavaSE本身就支持的），一是实现Parcelable接口（是Android特有功能，效率比实现Serializable接口高效，可用于Intent数据传递，也可以用于进程间通信（IPC））。实现Serializable接口非常简单，声明一下就可以了，而实现Parcelable接口稍微复杂一些，但效率更高，推荐用这种方法提高性能。
（2）为什么要序列化？
1）永久性保存对象，保存对象的字节序列到本地文件中；
2）通过序列化对象在网络中传递对象；
3）通过序列化在进程间传递对象。
（3）实现Parcelable步骤
1）implements Parcelable
2）重写writeToParcel方法，将你的对象序列化为一个Parcel对象，即：将类的数据写入外部提供的Parcel中，打包需要传递的数据到Parcel容器保存，以便从 Parcel容器获取数据
3）重写describeContents方法，内容接口描述，默认返回0就可以
4）实例化静态内部对象CREATOR实现接口Parcelable.Creator
public static final Parcelable.Creator&T& CREATOR
注：其中public static final一个都不能少，内部对象CREATOR的名称也不能改变，必须全部大写。需重写本接口中的两个方法：createFromParcel(Parcel in) 实现从Parcel容器中读取传递数据值，封装成Parcelable对象返回逻辑层，newArray(int
size) 创建一个类型为T，长度为size的数组，仅一句话即可（return new T[size]），供外部类反序列化本类数组使用。
总结：简而言之：
& & & &通过writeToParcel将你的对象映射成Parcel对象，再通过createFromParcel将Parcel对象映射成你的对象。也可以将Parcel看成是一个流，通过writeToParcel把对象写到流里面，在通过createFromParcel从流里读取对象，只不过这个过程需要你来实现，因此写的顺序和读的顺序必须一致。
这部分有点难哦，单单看文字表述还是很难学得懂得，所以看具体代码或许更能理解多一点，如果要真正掌握，那就必须用它去实现具体功能才能做到了。（实践是检验真理的唯一标准，还是要多练才行啊，单看是学不会编程的呀！）
import android.os.P
import android.os.P
public class InfoBean implements Parcelable {//序列化信息类
public InfoBean(String name){//构造方法
description =
public S//描述 -- 取一个字段（信息类InfoBean的一个属性）
public static final Parcelable.Creator&InfoBean& CREATOR
=new Parcelable.Creator&InfoBean&(){
* 2.再通过createFromParcel将Parcel对象映射成你的对象。
* @param source
public InfoBean createFromParcel(Parcel source) {
//再通过createFromParcel从流里读取对象
String description = source.readString();
//把对象保存在数据类对象的构造参数中，返回包含有数据的对象
return new InfoBean(description) ;
public InfoBean[] newArray(int size) {
return new InfoBean[size];
public int describeContents() {
* 1.通过writeToParcel将你的对象映射成Parcel对象，
* @param dest
* @param flags
public void writeToParcel(Parcel dest, int flags) {
//通过writeToParcel把对象写到流里面，
dest.writeString(description);
好难，想要表述清楚自己想说的东西不容易啊。希望下一次能进步一点点。
&&相关文章推荐
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：8722次
排名：千里之外
原创：14篇
(1)(1)(12)