如何使用Intents将对象从一个Android Activity发送到另一个？


How to send an object from one Android Activity to another using Intents?

如何使用类意图的putExtra()方法将自定义类型的对象从一个活动传递到另一个活动？

相关讨论

如果您只是在传递对象，那么Parcelable就是为此设计的。它比使用Java的原生序列化需要更多的努力，但它的速度更快(我的意思是，方式更快)。

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
// 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()将它们放入你的意图中：

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

然后您可以使用getParcelableextra()将它们拉出：

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

如果您的对象类实现了parcelable和serializable，那么请确保您执行了以下转换之一：

1
2
i.putExtra("parcelable_extra", (Parcelable) myParcelableObject);
i.putExtra("serializable_extra", (Serializable) myParcelableObject);
相关讨论

您需要将对象序列化为某种字符串表示形式。一种可能的字符串表示是JSON，如果你问我的话，在Android中序列化JSON的最简单方法之一就是通过Google GSON。

在这种情况下，您只需将来自(new Gson()).toJson(myObject);的字符串返回值放入并检索字符串值，然后使用fromJson将其转换回对象。

但是，如果您的对象不是很复杂，那么它可能不值得开销，您可以考虑传递对象的单独值。

相关讨论

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 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 {
}
相关讨论

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

以下是Dianne Hackborn(Hackbod，一位谷歌安卓软件工程师)对此事的看法：

For situations where you know the activities are running in the same
process, you can just share data through globals. For example, you
could have a global HashMap>
and when you make a new MyInterpreterState come up with a unique name
for it and put it in the hash map; to send that state to another
activity, simply put the unique name into the hash map and when the
second activity is started it can retrieve the MyInterpreterState from
the hash map with the name it receives.

相关讨论

类应该实现可序列化或Parcelable。

1
public class MY_CLASS implements Serializable

完成后，您可以在PutExtra上发送一个对象。

1
2
3
intent.putExtra("KEY", MY_CLASS_instance);

startActivity(intent);

要想得到额外的东西，你只需要做

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

如果类实现parcelable，请使用next

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

希望有帮助：d

相关讨论

快速需求的简短回答

1。将类实现为可序列化。

如果您有任何内部类，也不要忘记实现它们以便序列化！！

1
2
3
4
public class SportsData implements  Serializable
public class Sport implements  Serializable

List<Sport> clickedObj;

2。把你的目标集中起来

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

三。在另一个活动类中接收您的对象

1
2
Intent intent = getIntent();
    Sport cust = (Sport) intent.getSerializableExtra("sport");
相关讨论

如果对象类实现了Serializable，则不需要执行任何其他操作，可以传递一个可序列化的对象。我就是这么用的。

在类中实现可序列化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
        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;
        }
        }

然后你可以故意传递这个对象

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

在第二个活动中输入这样的数据

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

但当数据变大时，这种方法会变慢。

相关讨论

您可以使用Android捆绑包来完成此操作。

从类中创建一个包，如下所示：

1
2
3
4
5
6
public Bundle toBundle() {
    Bundle b = new Bundle();
    b.putString("SomeKey","SomeValue");

    return b;
}

然后故意传递这个包。现在，您可以通过像这样传递bundle来重新创建类对象

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

在自定义类中声明并使用。

相关讨论

感谢Parcelable的帮助，但我找到了另一个可选的解决方案

1
2
3
4
5
6
7
8
9
10
11
 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;
        }
    }

在活动一

1
2
3
4
5
6
7
8
9
10
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);

获取活动2中的数据

1
2
3
4
5
6
7
8
9
 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());
        }
相关讨论

有两种方法可以访问其他类或活动中的变量或对象。

A.数据库

b.共享偏好。

c.对象序列化。

可以保存公共数据的类可以命名为它依赖于您的公共实用程序。

e.通过intent和parcelable接口传递数据。

这取决于你的项目需要。

A.数据库

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

教程——http://www.vogella.com/articles/androidsqlite/article.html

B.共享偏好

假设您想要存储用户名。所以现在有两件事，一个密钥用户名，一个值。

如何存储

1
2
3
4
5
6
7
8
9
 // 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()、putloat()、putlong()可以保存所需的DTATYPE。

如何取回

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

http://developer.android.com/reference/android/content/sharedreferences.html

C.对象序列化

如果我们希望保存一个对象状态以通过网络发送它，或者您也可以将其用于您的目的，则使用对象serization。

使用JavaBean并将其存储为他的字段之一，并使用GETTER和SETTER

JavaBeans是具有属性的Java类。想想属性作为私有实例变量。因为他们是私人的，唯一的办法它们可以通过类中的方法从类外部访问。这个更改属性值的方法称为setter方法，方法检索属性值的方法称为getter方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class VariableStorage implements Serializable  {

    private String inString ;

    public String getInString() {
        return inString;
    }

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


}

通过使用

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

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

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

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

如果您想了解此教程，请参阅此链接

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

在其他类中获取变量

D.公用设施

您可以自己创建一个类，该类可以包含项目中经常需要的公共数据。

样品

1
2
3
4
5
public class CommonUtilities {

    public static String className ="CommonUtilities";

}

e.通过意图传递数据

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

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

相关讨论

我使用GSON及其强大而简单的API在活动之间发送对象，

例子

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// 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

1
2
3
4
5
6
7
    // 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接收

1
2
3
4
5
6
7
8
9
@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);
}

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

相关讨论

在您的第一个活动中：

1
intent.putExtra("myTag", yourObject);

在你的第二个例子中：

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

不要忘记使自定义对象可序列化：

1
2
3
public class myCustomObject implements Serializable {
...
}
相关讨论

我也在同一个问题上挣扎。我通过使用一个静态类来解决这个问题，将我想要的任何数据存储在哈希图中。在顶部，我使用标准活动类的扩展，在该类中，我重写了创建OnDestroy时的方法，以隐藏数据传输和数据清除。必须更改一些可笑的设置，例如方向处理。

注释：不提供一般的物品来参加另一项活动是很痛苦的。这就像在膝盖上开枪，希望赢得100米的比赛。""可烘烤"不是一个足够的替代品。它让我开怀大笑…我不想实现这个接口到我的无技术API，因为我不想引入一个新的层…怎么可能呢，我们在移动编程中离现代模式如此之远…

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

1
2
3
<application
    android:name=".MyApplication"
    ...

然后，您可以从任何活动调用它，并将对象保存到Application类。

在第一个活动中：

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

在第二个活动中，请执行以下操作：

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

如果您有具有应用程序级别范围的对象，即必须在整个应用程序中使用这些对象，那么这很方便。如果您想要对对象范围进行显式控制或者范围受到限制，那么Parcelable方法仍然更好。

不过，这样可以避免使用Intents。我不知道他们是否适合你。我使用的另一种方法是让对象的int标识符通过意图发送并检索我在Application对象中的地图中的对象。

相关讨论

在类模型(对象)中实现可序列化的例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class MensajesProveedor implements Serializable {

    private int idProveedor;


    public MensajesProveedor() {
    }

    public int getIdProveedor() {
        return idProveedor;
    }

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


}

你的第一次活动

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

第二项活动(新活动)

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

祝你好运！！

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
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];
        }
    };

}

传递数据：

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

检索数据：

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

我发现最简单的解决方法是……使用getters setter创建带有静态数据成员的类。

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

活动A

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

活动B

1
mytestclass obj= mytestclass.staticfunctionGet();
相关讨论

创建Android应用程序

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

输入项目名称：Android将对象传递到活动

邮箱：com.hmkcode.android

保留其他默认选项，继续下一步直到完成

在开始创建应用程序之前，我们需要创建pojo类"person"，用于将对象从一个活动发送到另一个活动。请注意，该类正在实现可序列化接口。

爪哇人

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
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 +"]";
    }  
}

两个活动的两个布局

活动main.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
<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>

活动其他.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<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>

两个活动类

1)活动主.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
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)其他活动.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
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());

}
}

您可以使用putsextra(serializable..)和getserializableextra()方法来传递和检索类类型的对象；您必须将类标记为可序列化，并确保所有成员变量也可序列化…

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

我知道这很晚了，但很简单。您所要做的就是让类实现类似

1
2
3
public class MyClass implements Serializable{

}

然后你可以传递到一个意图，比如

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

为了得到它，你简单的打电话

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

使用google的gson库，你可以将对象传递给其他活动。实际上，我们将以json字符串的形式转换对象，在传递给其他活动之后，我们将再次转换成这样的对象

考虑这样的bean类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 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;
    }
}

我们需要传递示例类的对象

1
2
3
4
5
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);

为了阅读，我们需要做下一步的逆向操作。

1
2
3
4
5
6
 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中添加此依赖项

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

如果您有一个singleton类(fx服务)作为您的模型层的网关，那么可以通过在该类中有一个带有getter和setter的变量来解决这个问题。

在活动1中：

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

在活动2中：

1
2
3
4
5
6
7
8
9
10
11
12
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.
}

在职：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
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;
}

此解决方案不需要对相关对象进行任何序列化或其他"打包"。但是，只有当您无论如何都在使用这种体系结构时，它才是有益的。

相关讨论

迄今为止，imho包裹对象的最简单方法。只需在要创建Parcelable的对象上方添加一个注释标记。

库中的一个示例如下：https://github.com/johncarl81/parceler

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
@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; }
}

首先在类中实现parcelable。然后像这样传递对象。

发送活动.java

1
2
3
4
5
6
7
8
ObjectA obj = new ObjectA();

// Set values etc.

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

startActivity(i);

接收活动.java

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

包字符串不是必需的，只是两个活动中的字符串必须相同

参考文献

从此活动启动另一个活动通过bundle对象传递参数

1
2
3
Intent intent = new Intent(getBaseContext(), YourActivity.class);
intent.putExtra("USER_NAME","[email protected]");
startActivity(intent);

检索另一个活动(您的实际活动)

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

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

这里有员工模型

1
2
3
4
5
6
7
8
class Employee{
    private String empId;
    private int age;
    print Double salary;

    getters...
    setters...
}

您可以使用google提供的gson lib来序列化复杂的数据。这样地

1
2
3
4
5
6
7
8
9
10
11
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);

最简单的方法是只在项目是字符串的情况下使用以下内容：

1
intent.putextra("selected_item",item)

接收：

1
String name = data.getStringExtra("selected_item");
相关讨论

如果您对使用PutExtra功能不是很特别，只想用对象启动另一个活动，那么您可以查看我编写的gnlauncher(https://github.com/noxiouswinter/gnlib_android/wiki_gnlauncher)库，以使这个过程更直接。

gnlauncher使从另一个活动等向活动发送对象/数据变得与使用所需数据作为参数调用活动中的函数一样容易。它引入了类型安全性，并消除了必须序列化、使用字符串键附加到意图以及在另一端撤消相同操作的所有麻烦。

在Koltin

在build.gradle中添加Kotlin扩展。

1
2
3
4
5
6
7
apply plugin: 'kotlin-android-extensions'

android {
    androidExtensions {
        experimental = true
   }
}

然后像这样创建数据类。

1
2
@Parcelize
data class Sample(val id: Int, val name: String) : Parcelable

有意传递对象

1
2
3
4
5
val sample = Sample(1,"naveen")

val intent = Intent(context, YourActivity::class.java)
    intent.putExtra("id", sample)
    startActivity(intent)

有目的地获取对象

1
val sample = intent.getParcelableExtra("id")

pojo类"post"(注意它是可序列化实现的)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
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类"comment"(由于是post类的成员，因此也需要实现序列化)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
    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。

1
2
3
4
5
6
7
8
9
10
11
12
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"中，可以按以下方式获取数据

1
Post post =(Post)getIntent().getSerializableExtra("post");
1
2
3
4
5
6
7
8
Start another activity from this activity pass parameters via Bundle Object

Intent intent = new Intent(this, YourActivity.class);
Intent.putExtra(AppConstants.EXTRAS.MODEL, cModel);
startActivity(intent);
Retrieve on another activity (YourActivity)

ContentResultData cModel = getIntent().getParcelableExtra(AppConstants.EXTRAS.MODEL);
相关讨论

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
We can send data one Activty1 to Activity2 with multiple ways like.
1- Intent
2- bundle
3- create an object and send through intent
.................................................
1 - Using intent
Pass the data through intent
Intent intentActivity1 = new Intent(Activity1.this, Activity2.class);
intentActivity1.putExtra("name","Android");
startActivity(intentActivity1);
Get the data in Activity2 calss
Intent intent = getIntent();
if(intent.hasExtra("name")){
     String userName = getIntent().getStringExtra("name");
}
..................................................
2- Using Bundle
Intent intentActivity1 = new Intent(Activity1.this, Activity2.class);
Bundle bundle = new Bundle();
bundle.putExtra("name","Android");
intentActivity1.putExtra(bundle);
startActivity(bundle);
Get the data in Activity2 calss
Intent intent = getIntent();
if(intent.hasExtra("name")){
     String userName = getIntent().getStringExtra("name");
}
..................................................
3-  Put your Object into Intent
Intent intentActivity1 = new Intent(Activity1.this, Activity2.class);
            intentActivity1.putExtra("myobject", myObject);
            startActivity(intentActivity1);
 Receive object in the Activity2 Class
Intent intent = getIntent();
    Myobject obj  = (Myobject) intent.getSerializableExtra("myobject");

我知道有点晚了，但是如果您只想为一些对象执行此操作，为什么不在目标活动中将对象声明为公共静态对象呢？

1
public static myObject = new myObject();

从你的源代码活动中给它一个价值？

1
destinationActivity.myObject = this.myObject;

在源活动中，您可以像使用任何全局对象一样使用它。对于大量对象，它可能会导致一些内存问题，但对于少数对象，我认为这是最好的方法。

相关讨论