提问



如何使用类Intent的putExtra()方法将自定义类型的对象从一个Activity传递到另一个Activity?[85] [86]

最佳参考


如果您只是传递对象,那么Parcelable就是为此设计的。它需要比使用Java的本机序列化更多的努力,但它的速度更快(我的意思是, WAY 更快)。[87]


从文档中,一个如何实现的简单示例是:


// simple class that just has one member property as an example
public class MyParcelable implements Parcelable {
    private int mData;

    /* everything below here is for implementing Parcelable */

    // 99.9% of the time you can just ignore this
    @Override
    public int describeContents() {
        return 0;
    }

    // write your object's data to the passed-in Parcel
    @Override
    public void writeToParcel(Parcel out, int flags) {
        out.writeInt(mData);
    }

    // this is used to regenerate your object. All Parcelables must have a CREATOR that implements these two methods
    public static final Parcelable.Creator<MyParcelable> CREATOR = new Parcelable.Creator<MyParcelable>() {
        public MyParcelable createFromParcel(Parcel in) {
            return new MyParcelable(in);
        }

        public MyParcelable[] newArray(int size) {
            return new MyParcelable[size];
        }
    };

    // example constructor that takes a Parcel and gives you an object populated with it's values
    private MyParcelable(Parcel in) {
        mData = in.readInt();
    }
}


请注意,如果您要从给定的包中检索多个字段,则必须按照放入它们的顺序(即采用FIFO方法)执行此操作。


一旦你的对象实现了Parcelable,它只需要用putExtra()将它们放入你的Intents:[88] [89]


Intent i = new Intent();
i.putExtra("name_of_extra", myParcelableObject);


然后你可以用getParcelableExtra()将它们拉回来:[90]


Intent i = getIntent();
MyParcelable myParcelableObject = (MyParcelable) i.getParcelableExtra("name_of_extra");


如果您的Object类实现了Parcelable和Serializable,那么请确保您执行以下操作之一:


i.putExtra("parcelable_extra", (Parcelable) myParcelableObject);
i.putExtra("serializable_extra", (Serializable) myParcelableObject);

其它参考1


您需要将对象序列化为某种字符串表示形式。一种可能的字符串表示形式是JSON,如果您问我,最简单的方法之一是在Android中序列化到/来自JSON,是通过Google GSON。[91]


在这种情况下,你将来自(new Gson()).toJson(myObject);的字符串返回值并检索字符串值并使用fromJson将其转回到对象中。


但是,如果您的对象不是非常复杂,则可能不值得花费开销,您可以考虑传递对象的单独值。

其它参考2


您可以通过意图发送可序列化对象


// send where details is object
ClassName details = new ClassName();
Intent i = new Intent(context, EditActivity.class);
i.putExtra("Editing", details);
startActivity(i);


//receive
ClassName model = (ClassName) getIntent().getSerializableExtra("Editing");

And 

Class ClassName implements Serializable {
} 

其它参考3


对于您知道将在应用程序中传递数据的情况,请使用globals(如静态类)


以下是Dianne Hackborn(hackbod - 谷歌Android软件工程师)对此事所说的话:[92] [93]



  对于您知道Activity正在运行的情况
  进程,你可以通过全局分享数据。例如,你
  可能有全球HashMap<String, WeakReference<MyInterpreterState>>
  当你创建一个新的MyInterpreterState时,会出现一个唯一的名称
  为它,并把它放在哈希映射;把那个州送到另一个州
  Activity,只需将唯一名称放入哈希映射中即可
  第二个Activity启动它可以从中检索MyInterpreterState
  哈希映射及其接收的名称。


其它参考4


您的类应该实现Serializable或Parcelable。


public class MY_CLASS implements Serializable


完成后,您可以在putExtra上发送一个对象


intent.putExtra("KEY", MY_CLASS_instance);

startActivity(intent);


要获得额外的东西你只需要做


Intent intent = getIntent();
MY_CLASS class = (MY_CLASS) intent.getExtras().getSerializable("KEY");


如果你的类实现Parcelable使用next


MY_CLASS class = (MY_CLASS) intent.getExtras().getParcelable("KEY");


我希望它有所帮助:D

其它参考5


如果你的对象类实现 Serializable ,你不需要做任何其他事情,你可以传递一个可序列化的对象。这就是我使用的东西。

其它参考6


快速需要的简短回答


1。将您的类实现为Serializable。


如果您有任何内部类,请不要忘记将它们实现为Serializable !!


public class SportsData implements  Serializable
public class Sport implements  Serializable

List<Sport> clickedObj;


2。将您的对象置于Intent


 Intent intent = new Intent(SportsAct.this, SportSubAct.class);
            intent.putExtra("sport", clickedObj);
            startActivity(intent);


第3。并在另一个Activity类中接收您的对象


Intent intent = getIntent();
    Sport cust = (Sport) intent.getSerializableExtra("sport");

其它参考7


你可以使用android BUNDLE来做到这一点。


从您的类创建一个Bundle,如:


public Bundle toBundle() {
    Bundle b = new Bundle();
    b.putString("SomeKey", "SomeValue");

    return b;
}


然后使用INTENT传递此捆绑包。
现在,您可以通过传递bundle来重新创建类对象


public CustomClass(Context _context, Bundle b) {
    context = _context;
    classMember = b.getString("SomeKey");
}


在Custom类中声明并使用。

其它参考8


感谢您的帮助,但我找到了一个可选的解决方案


 public class getsetclass implements Serializable {
        private int dt = 10;
    //pass any object, drwabale 
        public int getDt() {
            return dt;
        }

        public void setDt(int dt) {
            this.dt = dt;
        }
    }


在Activity一中


getsetclass d = new getsetclass ();
                d.setDt(50);
                LinkedHashMap<String, Object> obj = new LinkedHashMap<String, Object>();
                obj.put("hashmapkey", d);
            Intent inew = new Intent(SgParceLableSampelActivity.this,
                    ActivityNext.class);
            Bundle b = new Bundle();
            b.putSerializable("bundleobj", obj);
            inew.putExtras(b);
            startActivity(inew);


获取Activity2中的数据


 try {  setContentView(R.layout.main);
            Bundle bn = new Bundle();
            bn = getIntent().getExtras();
            HashMap<String, Object> getobj = new HashMap<String, Object>();
            getobj = (HashMap<String, Object>) bn.getSerializable("bundleobj");
            getsetclass  d = (getsetclass) getobj.get("hashmapkey");
        } catch (Exception e) {
            Log.e("Err", e.getMessage());
        }

其它参考9


在你的班级实现序列化


        public class Place implements Serializable{
        private int id;
        private String name;

        public void setId(int id) {
           this.id = id;
        }
        public int getId() {
           return id;
        }
        public String getName() {
           return name;
        }

        public void setName(String name) {
           this.name = name;
        }
        }


然后你可以在意图中传递这个对象


     Intent intent = new Intent(this, SecondAct.class);
     intent.putExtra("PLACE", Place);
     startActivity();


在第二个Activity中你可以获得这样的数据


     Place place= (Place) getIntent().getSerializableExtra("PLACE");


但是当数据变大时,这种方法会很慢。

其它参考10


您可以通过多种方式访问​​其他类或Activity中的变量或对象。


A.数据库


B.共享偏好。


C.对象序列化。


D.可以保存公共数据的类可以命名为依赖于您的Common Utilities。


E.通过Intents和Parcelable Interface传递数据。


这取决于您的项目需求。


A. 数据库


SQLite是一个嵌入到Android中的开源数据库。 SQLite支持标准的关系数据库功能,如SQL语法,事务和预准备语句。


教程 - http://www.vogella.com/articles/AndroidSQLite/article.html [94]


B. 共享首选项


假设您要存储用户名。因此,现在将有两个用户名,值。


如何存储


 // Create object of SharedPreferences.
 SharedPreferences sharedPref = PreferenceManager.getDefaultSharedPreferences(this);
 //now get Editor
 SharedPreferences.Editor editor = sharedPref.edit();
 //put your value
 editor.putString("userName", "stackoverlow");

 //commits your edits
 editor.commit();


使用putString(),putBoolean(),putInt(),putFloat(),putLong()可以保存所需的dtatype。


如何获取


SharedPreferences sharedPref = PreferenceManager.getDefaultSharedPreferences(this);
String userName = sharedPref.getString("userName", "Not Available");


http://developer.android.com/reference/android/content/SharedPreferences.html[95]


C. 对象序列化


如果我们想要保存对象状态以通过网络发送它,或者您也可以将它用于您的目的,则使用对象serlization。


使用java bean并将其作为其中一个字段存储在其中,并使用getter和setter


JavaBeans是具有属性的Java类。考虑到
属性作为私有实例变量。因为他们私有化,唯一的方式
可以通过类中的方法从类外部访问它们。该
更改属性值的方法称为setter方法和方法
检索属性的值称为getter方法。


public class VariableStorage implements Serializable  {

    private String inString ;

    public String getInString() {
        return inString;
    }

    public void setInString(String inString) {
        this.inString = inString;
    }


}


使用在邮件方法中设置变量


VariableStorage variableStorage = new VariableStorage();
variableStorage.setInString(inString);


然后使用对象序列化来序列化此对象,并在其他类中反序列化此对象。


在序列化中,对象可以表示为字节序列,其包括对象的数据以及关于对象的类型和存储在对象中的数据类型的信息。


将序列化对象写入文件后,可以从文件中读取并反序列化,即表示对象及其数据的类型信息和字节可用于在内存中重新创建对象。


如果您想要这方面的教程,请参阅此链接


http://javawithswaranga.blogspot.in/2011/08/serialization-in-java.html[96]


在其他类中获取变量


D. CommonUtilities


您可以自己创建一个类,它可以包含项目中经常需要的常用数据。


样品


public class CommonUtilities {

    public static String className = "CommonUtilities";

}


E. 通过意图传递数据


有关传递数据的此选项,请参阅本教程。


http://shri.blog.kraya.co.uk/2010/04/26/android-parcel-data-to-pass-between-activities-using-parcelable-classes/[98]

其它参考11


我使用Gson的强大而简单的api在Activity之间发送对象,


实施例


// This is the object to be sent, can be any object
public class AndroidPacket {

    public String CustomerName;

   //constructor
   public AndroidPacket(String cName){
       CustomerName = cName;
   }   
   // other fields ....


    // You can add those functions as LiveTemplate !
    public String toJson() {
        Gson gson = new Gson();
        return gson.toJson(this);
    }

    public static AndroidPacket fromJson(String json) {
        Gson gson = new Gson();
        return gson.fromJson(json, AndroidPacket.class);
    }
}


将您添加到要发送的对象的2个函数


用法


将对象从A发送到B


    // Convert the object to string using Gson
    AndroidPacket androidPacket = new AndroidPacket("Ahmad");
    String objAsJson = androidPacket.toJson();

    Intent intent = new Intent(A.this, B.class);
    intent.putExtra("my_obj", objAsJson);
    startActivity(intent);


接收B


@Override
protected void onCreate(Bundle savedInstanceState) {        
    Bundle bundle = getIntent().getExtras();
    String objAsJson = bundle.getString("my_obj");
    AndroidPacket androidPacket = AndroidPacket.fromJson(objAsJson);

    // Here you can use your Object
    Log.d("Gson", androidPacket.CustomerName);
}


我几乎在我做的每个项目中使用它,我没有性能问题。

其它参考12


我在同样的问题上挣扎。我通过使用静态类来解决它,在HashMap中存储我想要的任何数据。最重要的是,我使用标准Activity类的扩展,我已经覆盖了onCreate onDestroy上的方法来隐藏数据传输和数据清除。一些荒谬的设置必须改变,例如定位处理。


注解:
不提供传递给另一个Activity的一般对象是痛苦的屁股。这就像是在膝盖上射击,并希望赢得100米。Parcable不是一个充分的替代品。它让我笑了......我不想实现这个界面到我的无技术API,如我想引入一个新的图层...怎么可能,我们在移动编程中远离现代范式......

其它参考13


在您的第一个Activity中:


intent.putExtra("myTag", yourObject);


在你的第二个:


myCustomObject myObject = (myCustomObject) getIntent().getSerializableExtra("myTag");


别忘了让你的自定义对象Serializable:


public class myCustomObject implements Serializable {
...
}

其它参考14


另一种方法是使用Application对象(android.app.Application)。您可以在AndroidManifest.xml文件中将其定义为:


<application
    android:name=".MyApplication"
    ...


然后,您可以从任何Activity中调用此对象并将对象保存到Application类。


在FirstActivity中:


MyObject myObject = new MyObject();
MyApplication app = (MyApplication) getApplication();
app.setMyObject(myObject);


在SecondActivity中,执行:


MyApplication app = (MyApplication) getApplication();
MyObject retrievedObject = app.getMyObject(myObject);


如果您具有具有应用程序级别范围的对象,即在整个应用程序中必须使用它们,这将非常方便。如果要显式控制对象范围或范围有限,Parcelable方法仍然更好。


但这完全避免了Intents的使用。我不知道它们是否适合你。我使用它的另一种方法是让int对象的标识符通过意图发送并检索我在Application对象中的Maps中的对象。

其它参考15


在你的类模型(Object)中实现Serializable,for
例:


public class MensajesProveedor implements Serializable {

    private int idProveedor;


    public MensajesProveedor() {
    }

    public int getIdProveedor() {
        return idProveedor;
    }

    public void setIdProveedor(int idProveedor) {
        this.idProveedor = idProveedor;
    }


}


和你的第一个Activity


MensajeProveedor mp = new MensajeProveedor();
Intent i = new Intent(getApplicationContext(), NewActivity.class);
                i.putExtra("mensajes",mp);
                startActivity(i);


和你的第二个Activity(NewActivity)


        MensajesProveedor  mensajes = (MensajesProveedor)getIntent().getExtras().getSerializable("mensajes");


祝你好运!!

其它参考16


public class SharedBooking implements Parcelable{

    public int account_id;
    public Double betrag;
    public Double betrag_effected;
    public int taxType;
    public int tax;
    public String postingText;

    public SharedBooking() {
        account_id = 0;
        betrag = 0.0;
        betrag_effected = 0.0;
        taxType = 0;
        tax = 0;
        postingText = "";
    }

    public SharedBooking(Parcel in) {
        account_id = in.readInt();
        betrag = in.readDouble();
        betrag_effected = in.readDouble();
        taxType = in.readInt();
        tax = in.readInt();
        postingText = in.readString();
    }

    public int getAccount_id() {
        return account_id;
    }
    public void setAccount_id(int account_id) {
        this.account_id = account_id;
    }
    public Double getBetrag() {
        return betrag;
    }
    public void setBetrag(Double betrag) {
        this.betrag = betrag;
    }
    public Double getBetrag_effected() {
        return betrag_effected;
    }
    public void setBetrag_effected(Double betrag_effected) {
        this.betrag_effected = betrag_effected;
    }
    public int getTaxType() {
        return taxType;
    }
    public void setTaxType(int taxType) {
        this.taxType = taxType;
    }
    public int getTax() {
        return tax;
    }
    public void setTax(int tax) {
        this.tax = tax;
    }
    public String getPostingText() {
        return postingText;
    }
    public void setPostingText(String postingText) {
        this.postingText = postingText;
    }
    public int describeContents() {
        // TODO Auto-generated method stub
        return 0;
    }
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeInt(account_id);
        dest.writeDouble(betrag);
        dest.writeDouble(betrag_effected);
        dest.writeInt(taxType);
        dest.writeInt(tax);
        dest.writeString(postingText);

    }

    public static final Parcelable.Creator<SharedBooking> CREATOR = new Parcelable.Creator<SharedBooking>()
    {
        public SharedBooking createFromParcel(Parcel in)
        {
            return new SharedBooking(in);
        }
        public SharedBooking[] newArray(int size)
        {
            return new SharedBooking[size];
        }
    };

}





传递数据:


Intent intent = new Intent(getApplicationContext(),YourActivity.class);
Bundle bundle = new Bundle();
i.putParcelableArrayListExtra("data", (ArrayList<? extends Parcelable>) dataList);
intent.putExtras(bundle);
startActivity(intent);


检索数据


Bundle bundle = getIntent().getExtras();
dataList2 = getIntent().getExtras().getParcelableArrayList("data");

其它参考17


我找到的最简单的解决方案是......
使用具有getter setter的静态数据成员创建一个类。


从一个Activity设置并从另一个Activity获取该对象。


ActivityA.


mytestclass.staticfunctionSet("","",""..etc.);


Activityb


mytestclass obj= mytestclass.staticfunctionGet();

其它参考18


你可以使用putExtra(Serializable ..)和getSerializableExtra()方法来传递和检索你的类类型的对象;你必须标记你的Serializable类,并确保你的所有成员变量都是可序列化的......

其它参考19


创建Android应用程序


文件>>新>> Android应用程序


输入项目名称:android-pass-object-to-activity


Pakcage:com.hmkcode.android


保持其他defualt选择,转到下一步,直到你完成


在开始创建App之前,我们需要创建POJO类Person,我们将使用它来将对象从一个Activity发送到另一个Activity。请注意,该类正在实现Serializable接口。


Person.java


package com.hmkcode.android;
import java.io.Serializable;

public class Person implements Serializable{

    private static final long serialVersionUID = 1L;

    private String name;
    private int age;

        // getters & setters....

    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }   
}


两项Activity的两个布局


activity_main.xml中


<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical"
tools:context=".MainActivity" >

<LinearLayout
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:orientation="horizontal">
    <TextView
        android:id="@+id/tvName"
        android:layout_width="100dp"
        android:layout_height="wrap_content"
        android:layout_gravity="center"
        android:gravity="center_horizontal"
        android:text="Name" />

    <EditText
        android:id="@+id/etName"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"

        android:ems="10" >
        <requestFocus />
    </EditText>
</LinearLayout>

<LinearLayout
     android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:orientation="horizontal">
<TextView
    android:id="@+id/tvAge"
    android:layout_width="100dp"
    android:layout_height="wrap_content"
    android:layout_gravity="center"
    android:gravity="center_horizontal"
    android:text="Age" />
<EditText
    android:id="@+id/etAge"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:ems="10" />
</LinearLayout>

<Button
    android:id="@+id/btnPassObject"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:layout_gravity="center_horizontal"
    android:text="Pass Object to Another Activity" />

</LinearLayout>


activity_another.xml


<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical"
 >

<TextView
    android:id="@+id/tvPerson"
    android:layout_height="wrap_content"
    android:layout_width="fill_parent"
    android:layout_gravity="center"
    android:gravity="center_horizontal"
 />

</LinearLayout>


两个Activity类


1)ActivityMain.java


package com.hmkcode.android;

import android.os.Bundle;
import android.app.Activity;
import android.content.Intent;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.EditText;

public class MainActivity extends Activity implements OnClickListener {

Button btnPassObject;
EditText etName, etAge;
@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    btnPassObject = (Button) findViewById(R.id.btnPassObject);
    etName = (EditText) findViewById(R.id.etName);
    etAge = (EditText) findViewById(R.id.etAge);

    btnPassObject.setOnClickListener(this);
}

@Override
public void onClick(View view) {

    // 1. create an intent pass class name or intnet action name 
    Intent intent = new Intent("com.hmkcode.android.ANOTHER_ACTIVITY");

    // 2. create person object
    Person person = new Person();
    person.setName(etName.getText().toString());
    person.setAge(Integer.parseInt(etAge.getText().toString()));

    // 3. put person in intent data
    intent.putExtra("person", person);

    // 4. start the activity
    startActivity(intent);
}

}


2)AnotherActivity.java


package com.hmkcode.android;

import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.widget.TextView;

public class AnotherActivity extends Activity {

TextView tvPerson;

@Override
protected void onCreate(Bundle savedInstanceState) {
    // TODO Auto-generated method stub
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_another);

    // 1. get passed intent 
    Intent intent = getIntent();

    // 2. get person object from intent
    Person person = (Person) intent.getSerializableExtra("person");

    // 3. get reference to person textView 
    tvPerson = (TextView) findViewById(R.id.tvPerson);

    // 4. display name & age on textView 
    tvPerson.setText(person.toString());

}
}

其它参考20


Intent i = new Intent();
i.putExtra("name_of_extra", myParcelableObject);
startACtivity(i);

其它参考21


我知道这已经很晚了,但它很简单。你所做的就是让你的类实现Serializable之类的


public class MyClass implements Serializable{

}


那么你可以传递给一个意图


Intent intent=......
MyClass obje=new MyClass();
intent.putExtra("someStringHere",obje);


为了得到你简单的电话


MyClass objec=(MyClass)intent.getExtra("theString");

其它参考22


使用谷歌的Gson库,你可以将对象传递给另一个Activity。实际上我们将以json字符串的形式转换对象,并在传递给其他Activity后,我们将再次重新转换为这样的对象


考虑像这样的bean类


 public class Example {
    private int id;
    private String name;

    public Example(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}


我们需要传递Example类的对象


Example exampleObject=new Example(1,"hello");
String jsonString = new Gson().toJson(exampleObject);
Intent nextIntent=new Intent(this,NextActivity.class);
nextIntent.putExtra("example",jsonString );
startActivity(nextIntent);


对于读取,我们需要在NextActivity中执行反向操作


 Example defObject=new Example(-1,null);
    //default value to return when example is not available
    String defValue= new Gson().toJson(defObject);
    String jsonString=getIntent().getExtras().getString("example",defValue);
    //passed example object
    Example exampleObject=new Gson().fromJson(jsonString,Example .class);


在gradle中添加此依赖项


compile 'com.google.code.gson:gson:2.6.2'

其它参考23


最简单的方法是在项目为字符串时使用以下内容:


intent.putextra("selected_item",item)


接收:


String name = data.getStringExtra("selected_item");

其它参考24


如果你有一个单例类(fx服务)作为你的模型层的网关,它可以通过在该类中使用带有getter和setter的变量来解决。


在Activity1中:


Intent intent = new Intent(getApplicationContext(), Activity2.class);
service.setSavedOrder(order);
startActivity(intent);


在Activity2中:


private Service service;
private Order order;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_quality);

    service = Service.getInstance();
    order = service.getSavedOrder();
    service.setSavedOrder(null) //If you don't want to save it for the entire session of the app.
}


在服务中:


private static Service instance;

private Service()
{
    //Constructor content
}

public static Service getInstance()
{
    if(instance == null)
    {
        instance = new Service();
    }
    return instance;
}
private Order savedOrder;

public Order getSavedOrder()
{
    return savedOrder;
}

public void setSavedOrder(Order order)
{
    this.savedOrder = order;
}


该解决方案不需要对所讨论的对象进行任何序列化或其他打包。但无论如何,只有使用这种架构才会有益。

其它参考25


到目前为止,恕我直言的最简单的方式包裹对象。您只需在要使其可分割的对象上方添加注释标记。


图书馆的一个例子在https://github.com/johncarl81/parceler [[]] [[]]下面。


@Parcel
public class Example {
    String name;
    int age;

    public Example(){ /*Required empty bean constructor*/ }

    public Example(int age, String name) {
        this.age = age;
        this.name = name;
    }

    public String getName() { return name; }

    public int getAge() { return age; }
}

其它参考26


首先在班级中实施 Parcelable 。然后像这样传递对象。


SendActivity.java


ObjectA obj = new ObjectA();

// Set values etc.

Intent i = new Intent(this, MyActivity.class);
i.putExtra("com.package.ObjectA", obj);

startActivity(i);


ReceiveActivity.java


Bundle b = getIntent().getExtras();
ObjectA obj = b.getParcelable("com.package.ObjectA");


包字符串不是必需的,只是字符串在两个Activity中都需要相同


参考 [100]

其它参考27


通过Bundle Object从此Activity传递参数启动另一个Activity


Intent intent = new Intent(getBaseContext(), YourActivity.class);
intent.putExtra("USER_NAME", "xyz@gmail.com");
startActivity(intent);


检索另一个Activity(YourActivity)


String s = getIntent().getStringExtra("USER_NAME");


对于简单类型的数据类型,这是可以的。
但是如果你想在Activity之间传递复杂的数据,你需要先将它序列化。


这里我们有员工模型


class Employee{
    private String empId;
    private int age;
    print Double salary;

    getters...
    setters...
}


您可以使用谷歌提供的Gson lib来序列化复杂数据
喜欢这个


String strEmp = new Gson().toJson(emp);
Intent intent = new Intent(getBaseContext(), YourActivity.class);
intent.putExtra("EMP", strEmp);
startActivity(intent);

Bundle bundle = getIntent().getExtras();
    String empStr = bundle.getString("EMP");
            Gson gson = new Gson();
            Type type = new TypeToken<Employee>() {
            }.getType();
            Employee selectedEmp = gson.fromJson(empStr, type);

其它参考28


如果你不是非常特别关于使用putExtra功能而只是想用对象启动另一个Activity,你可以查看我试图写的GNLauncher(https://github.com/noxiouswinter/gnlib_android/wiki#gnlauncher)库使这个过程更加直接。[101]


GNLauncher使对象/数据从另一个Activity等发送到Activity,就像调用Activity中的一个函数一样简单,并将所需的数据作为参数。它引入了类型安全性并消除了必须序列化的所有麻烦,使用字符串键附加到intent并在另一端撤消它。

其它参考29


POJO类发布(注意它实现了Serializable)


package com.example.booklib;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;

import android.graphics.Bitmap;

public class Post implements Serializable{
    public String message;
    public String bitmap;
    List<Comment> commentList = new ArrayList<Comment>();
    public String getMessage() {
        return message;
    }
    public void setMessage(String message) {
        this.message = message;
    }
    public String getBitmap() {
        return bitmap;
    }
    public void setBitmap(String bitmap) {
        this.bitmap = bitmap;
    }
    public List<Comment> getCommentList() {
        return commentList;
    }
    public void setCommentList(List<Comment> commentList) {
        this.commentList = commentList;
    }

}


POJO类注释(由于是Post类的成员,因此还需要实现Serializable)


    package com.example.booklib;

    import java.io.Serializable;

    public class Comment implements Serializable{
        public String message;
        public String fromName;
        public String getMessage() {
            return message;
        }
        public void setMessage(String message) {
            this.message = message;
        }
        public String getFromName() {
            return fromName;
        }
        public void setFromName(String fromName) {
            this.fromName = fromName;
        }

    }


然后在您的Activity类中,您可以执行以下操作将对象传递给另一个Activity。


ListView listview = (ListView) findViewById(R.id.post_list);
listview.setOnItemClickListener(new OnItemClickListener(){
        @Override
        public void onItemClick(AdapterView<?> parent, View view,
                int position, long id) {
            Post item = (Post)parent.getItemAtPosition(position);
            Intent intent = new Intent(MainActivity.this,CommentsActivity.class);
            intent.putExtra("post",item);
            startActivity(intent);

        }
    });


在您的收件人类CommentsActivity中,您可以获取以下数据


Post post =(Post)getIntent().getSerializableExtra("post");