问问题
666924 次
35 回答
789
如果您只是传递对象，那么Parcelable就是为此而设计的。使用它比使用 Java 的本机序列化需要更多的努力，但它更快（我的意思是，更快）。
从文档中，如何实现的一个简单示例是：
// 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();
}
}
请注意，如果您要从给定 Parcel 中检索多个字段，则必须按照放入它们的相同顺序执行此操作（即，采用 FIFO 方法）。
实现对象后，只需使用putExtra()Parcelable将它们放入Intent即可：
Intent i = new Intent();
i.putExtra("name_of_extra", myParcelableObject);
然后你可以用getParcelableExtra()把它们拉出来：
Intent i = getIntent();
MyParcelable myParcelableObject = (MyParcelable) i.getParcelableExtra("name_of_extra");
如果您的 Object Class 实现 Parcelable 和 Serializable 则确保您确实转换为以下之一：
i.putExtra("parcelable_extra", (Parcelable) myParcelableObject);
i.putExtra("serializable_extra", (Serializable) myParcelableObject);
于 2010-01-26T17:17:02.413 回答
206
您需要将对象序列化为某种字符串表示形式。一种可能的字符串表示形式是 JSON，如果您问我，在 android 中序列化到/从 JSON 序列化的最简单方法之一是通过Google GSON。
在这种情况下，您只需从中输入字符串返回值(new Gson()).toJson(myObject);并检索字符串值并使用fromJson将其转回您的对象。
但是，如果您的对象不是很复杂，那么开销可能不值得，您可以考虑改为传递对象的单独值。
于 2010-01-26T12:24:06.970 回答
162
您可以通过意图发送可序列化对象
// 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 {
}
于 2012-09-13T07:38:33.890 回答
70
对于您知道将在应用程序中传递数据的情况，请使用“全局”（如静态类）
以下是Dianne Hackborn（hackbod - 一位 Google Android 软件工程师）对此事的看法：
对于您知道活动在同一进程中运行的情况，您可以通过全局变量共享数据。例如，你可以有一个全局的
HashMap<String, WeakReference<MyInterpreterState>>，当你创建一个新的 MyInterpreterState 时，为它想出一个唯一的名称并将它放在哈希映射中；要将状态发送到另一个活动，只需将唯一名称放入哈希映射中，当第二个活动启动时，它可以使用它接收到的名称从哈希映射中检索 MyInterpreterState。
于 2011-11-02T17:40:43.860 回答
51
你的类应该实现 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 使用下一个
MY_CLASS class = (MY_CLASS) intent.getExtras().getParcelable("KEY");
我希望它有帮助：D
于 2013-04-23T18:41:11.167 回答
36
快速需求的简短答案
1. 将您的类实现为可序列化。
如果您有任何内部类，请不要忘记将它们实现为 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.并在其他活动类中接收您的对象
Intent intent = getIntent();
Sport cust = (Sport) intent.getSerializableExtra("sport");
于 2017-07-14T07:34:06.260 回答
32
在你的类中实现可序列化
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(intent);
在第二个活动中，您可以获得这样的数据
Place place= (Place) getIntent().getSerializableExtra("PLACE");
但是当数据变大时，这种方法会很慢。
于 2016-09-22T06:18:49.213 回答
28
如果你的对象类实现Serializable了，你不需要做任何其他事情，你可以传递一个可序列化的对象。
这就是我使用的。
于 2011-08-07T15:59:50.923 回答
21
有几种方法可以访问其他类或 Activity 中的变量或对象。
A. 数据库
B. 共享偏好。
C. 对象序列化。
D. 可以保存公共数据的类可以命名为 Common Utilities，这取决于您。
E. 通过 Intents 和 Parcelable 接口传递数据。
这取决于您的项目需求。
A.数据库
SQLite 是一个嵌入到 Android 中的开源数据库。SQLite 支持标准的关系数据库功能，如 SQL 语法、事务和准备好的语句。
教程——http: //www.vogella.com/articles/AndroidSQLite/article.html
B.共同偏好
假设您要存储用户名。所以现在会有两件事，一个关键用户名，一个价值价值。
如何储存
// Create an 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() 您可以保存所需的数据类型。
如何获取
SharedPreferences sharedPref = PreferenceManager.getDefaultSharedPreferences(this);
String userName = sharedPref.getString("userName", "Not Available");
http://developer.android.com/reference/android/content/SharedPreferences.html
C.对象序列化
如果我们想保存对象状态以通过网络发送它，则使用对象序列化，或者您也可以将其用于您的目的。
使用 java bean 并将其存储为他的字段之一，并为此使用 getter 和 setter
JavaBean 是具有属性的 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://javawithswranga.blogspot.in/2011/08/serialization-in-java.html
D. CommonUtilities
您可以自己创建一个类，其中可以包含您在项目中经常需要的常用数据。
样本
public class CommonUtilities {
public static String className = "CommonUtilities";
}
E.通过 Intent 传递数据
请参阅本教程以了解此传递数据的选项。
于 2013-06-25T20:10:47.267 回答
16
您可以使用 android 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");
}
在您的自定义类中声明它并使用。
于 2011-03-27T18:16:52.153 回答
16
感谢您的帮助，但我找到了另一种可选解决方案
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;
}
}
在活动一中
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 中获取数据
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());
}
于 2012-04-05T08:08:44.803 回答
14
我使用 Gson 及其强大而简单的 api 在活动之间发送对象，
例子
// 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);
}
我几乎在我所做的每个项目中都使用它，并且没有性能问题。
于 2016-02-26T14:22:04.923 回答
10
我在同样的问题上苦苦挣扎。我通过使用静态类来解决它，将我想要的任何数据存储在 HashMap 中。最重要的是，我使用标准 Activity 类的扩展，在该类中我覆盖了方法 onCreate 和 onDestroy 来执行隐藏的数据传输和数据清除。必须更改一些荒谬的设置，例如方向处理。
注释：不提供要传递给另一个 Activity 的一般对象是很痛苦的。这就像在膝盖中射击自己并希望赢得 100 米。“Parcable”不是一个充分的替代品。这让我发笑……我不想在我的无技术 API 中实现这个接口，因为我更不想引入一个新的层……怎么可能，我们在移动编程中离得这么远现代范式...
于 2012-09-10T23:13:34.270 回答
9
在您的第一个活动中：
intent.putExtra("myTag", yourObject);
在你的第二个：
myCustomObject myObject = (myCustomObject) getIntent().getSerializableExtra("myTag");
不要忘记使您的自定义对象可序列化：
public class myCustomObject implements Serializable {
...
}
于 2013-10-19T08:35:38.617 回答
7
另一种方法是使用Application对象 (android.app.Application)。您在AndroidManifest.xml文件中将其定义为：
<application
android:name=".MyApplication"
...
然后，您可以从任何活动中调用它并将对象保存到Application类中。
在第一个活动中：
MyObject myObject = new MyObject();
MyApplication app = (MyApplication) getApplication();
app.setMyObject(myObject);
在 SecondActivity 中，执行：
MyApplication app = (MyApplication) getApplication();
MyObject retrievedObject = app.getMyObject(myObject);
如果您有具有应用程序级别范围的对象，即它们必须在整个应用程序中使用，这将很方便。Parcelable如果您想要明确控制对象范围或范围有限，则该方法仍然更好。
不过，这完全避免了使用Intents。我不知道他们是否适合你。我使用它的另一种方法是让int对象的标识符通过意图发送并检索我在对象中的 Maps 中拥有的Application对象。
于 2012-12-18T23:11:38.327 回答
7
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");
于 2016-01-08T21:38:55.533 回答
7
在您的类模型（对象）中实现可序列化，例如：
public class MensajesProveedor implements Serializable {
private int idProveedor;
public MensajesProveedor() {
}
public int getIdProveedor() {
return idProveedor;
}
public void setIdProveedor(int idProveedor) {
this.idProveedor = idProveedor;
}
}
和你的第一个活动
MensajeProveedor mp = new MensajeProveedor();
Intent i = new Intent(getApplicationContext(), NewActivity.class);
i.putExtra("mensajes",mp);
startActivity(i);
和你的第二个活动（NewActivity）
MensajesProveedor mensajes = (MensajesProveedor)getIntent().getExtras().getSerializable("mensajes");
祝你好运！！
于 2015-08-26T01:10:21.377 回答
5
我找到的最简单的解决方案是.. 使用 getter setter 创建一个具有静态数据成员的类。
从一个活动中设置并从另一个活动中获取该对象。
活动A
mytestclass.staticfunctionSet("","",""..etc.);
活动b
mytestclass obj= mytestclass.staticfunctionGet();
于 2010-02-10T11:52:00.863 回答
5
使用 google 的 Gson 库，您可以将对象传递给另一个活动。实际上，我们将以 json 字符串的形式转换对象，在传递给其他活动后，我们将再次像这样重新转换为对象
考虑一个像这样的 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'
于 2016-09-07T04:57:11.097 回答
4
you can use putExtra(Serializable..) and getSerializableExtra() methods to pass and retrieve objects of your class type; you will have to mark your class Serializable and make sure that all your member variables are serializable too...
于 2011-10-06T16:00:09.860 回答
4
创建安卓应用
文件 >> 新建 >> Android 应用程序
输入项目名称：android-pass-object-to-activity
包：com.hmkcode.android
保留其他默认选择，继续下一步直到完成
在开始创建应用程序之前，我们需要创建 POJO 类“Person”，我们将使用它来将对象从一个活动发送到另一个活动。请注意，该类正在实现 Serializable 接口。
人.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_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>
两个活动课程
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）另一个活动.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());
}
}
于 2013-11-27T05:53:41.370 回答
4
我知道这已经晚了，但它很简单。你所要做的就是让你的类实现 Serializable 像
public class MyClass implements Serializable{
}
然后您可以传递给类似的意图
Intent intent=......
MyClass obje=new MyClass();
intent.putExtra("someStringHere",obje);
要得到它，你可以简单地打电话
MyClass objec=(MyClass)intent.getExtra("theString");
于 2016-08-13T12:44:02.513 回答
3
Intent i = new Intent();
i.putExtra("name_of_extra", myParcelableObject);
startACtivity(i);
于 2013-12-16T09:51:17.390 回答
3
如果您有一个单例类（fx 服务）作为模型层的网关，则可以通过在该类中使用带有 getter 和 setter 的变量来解决它。
在活动 1 中：
Intent intent = new Intent(getApplicationContext(), Activity2.class);
service.setSavedOrder(order);
startActivity(intent);
在活动 2 中：
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;
}
该解决方案不需要对相关对象进行任何序列化或其他“打包”。但只有在您使用这种架构时才会有好处。
于 2015-06-24T07:42:04.277 回答
3
通过 Bundle Object 从此活动传递参数开始另一个活动
Intent intent = new Intent(getBaseContext(), YourActivity.class);
intent.putExtra("USER_NAME", "xyz@gmail.com");
startActivity(intent);
检索另一个活动 (YourActivity)
String s = getIntent().getStringExtra("USER_NAME");
这对于简单类型的数据类型是可以的。但是如果你想在活动之间传递复杂的数据，你需要先序列化它。
这里我们有员工模型
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);
于 2017-06-23T11:59:23.297 回答
3
首先在你的类中实现 Parcelable。然后像这样传递对象。
发送活动.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");
包字符串不是必需的，只是两个活动中的字符串需要相同
于 2016-11-19T08:05:20.910 回答
3
在科尔廷
在 build.gradle 中添加 kotlin 扩展。
apply plugin: 'kotlin-android-extensions'
android {
androidExtensions {
experimental = true
}
}
然后像这样创建你的数据类。
@Parcelize
data class Sample(val id: Int, val name: String) : Parcelable
有意图地传递对象
val sample = Sample(1,"naveen")
val intent = Intent(context, YourActivity::class.java)
intent.putExtra("id", sample)
startActivity(intent)
有意图地获取对象
val sample = intent.getParcelableExtra("id")
于 2019-02-15T06:43:37.913 回答
3
最简单的 java 方法是：在你的 pojo/model 类中实现可序列化
推荐用于 Android 的性能视图：使模型可打包
于 2019-07-03T02:28:58.140 回答
3
到目前为止，恕我直言，包裹物体的最简单方法。您只需在您希望使其可打包的对象上方添加一个注释标签。
图书馆的一个例子如下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; }
}
于 2015-10-07T21:42:09.907 回答
1
如果您对使用 putExtra 功能不是很讲究，只想用对象启动另一个活动，您可以查看我尝试编写的 GNLauncher ( https://github.com/noxiouswinter/gnlib_android/wiki#gnlauncher ) 库使这个过程更直接。
GNLauncher 使从另一个 Activity 等向 Activity 发送对象/数据就像在 Activity 中使用所需数据作为参数调用函数一样简单。它引入了类型安全并消除了必须序列化的所有麻烦，使用字符串键附加到意图并在另一端撤消相同的操作。
于 2014-11-02T15:29:19.717 回答
0
POJO 类“Post ”（注意它实现了 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类“Comment”（由于是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;
}
}
然后在您的活动类中，您可以执行以下操作将对象传递给另一个活动。
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");
于 2016-10-21T07:24:18.283 回答
-1
最简单的方法是在项目是字符串的情况下使用以下内容：
intent.putextra("selected_item",item)
对于接收：
String name = data.getStringExtra("selected_item");
于 2010-06-24T10:10:36.687 回答
-1
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");
于 2019-02-15T06:20:21.050 回答
-1
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);
于 2018-12-20T11:52:24.453 回答
-5
我知道这有点晚了，但是如果您只想对几个对象执行此操作，为什么不将您的对象声明为目标活动中的公共静态对象？
public static myObject = new myObject();
并从您的源活动中给它一个值？
destinationActivity.myObject = this.myObject;
在您的源活动中，您可以像使用任何全局对象一样使用它。对于大量对象，它可能会导致一些内存问题，但对于少数对象，我认为这是最好的方法
于 2014-12-01T09:40:37.710 回答