如何使用Intents将对象从一个Android活动发送到另一个?

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

683878 次浏览

你需要将你的对象序列化为某种字符串表示。一种可能的字符串表示是JSON,如果你问我,在android中序列化到/从JSON的最简单方法之一是通过谷歌GSON

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

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

如果你只是传递对象,那么可包裹就是为此而设计的。它比使用Java的本机序列化需要更多的努力,但它更快(我的意思是,更快)。

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

// simple class that just has one member property as an examplepublic class MyParcelable implements Parcelable {private int mData;
/* everything below here is for implementing Parcelable */
// 99.9% of the time you can just ignore this@Overridepublic int describeContents() {return 0;}
// write your object's data to the passed-in Parcel@Overridepublic 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 methodspublic 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 valuesprivate MyParcelable(Parcel in) {mData = in.readInt();}}

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

一旦你让你的对象实现了Parcelable,只需用putExtra()将它们放入你的意图

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

然后你可以用getParcelableExtra()获取商品列表把它们拉回来:

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

如果您的对象类实现了Parcelable和Serializable,那么请确保您确实转换为以下之一:

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

我找到的最简单的方法是…使用getter setter创建具有静态数据成员的类。

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

活动A

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

活动b

mytestclass obj= mytestclass.staticfunctionGet();

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

intent.putextra("selected_item",item)

接收:

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

您可以使用android bundle来执行此操作。

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

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

然后用INTENT传递这个包。现在你可以通过传递像

这样的包来重新创建你的类对象
public CustomClass(Context _context, Bundle b) {context = _context;classMember = b.getString("SomeKey");}

在您的Custom类中声明并使用它。

如果你的对象类实现了Serializable,你不需要做任何其他事情,你可以传递一个可序列化的对象。

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

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

这里黛安·哈克伯恩(hackbod-谷歌Android软件工程师)对此事的看法:

对于您知道活动在相同环境中运行的情况进程,您可以只通过全局变量共享数据。例如,您可以有一个全局HashMap<String, WeakReference<MyInterpreterState>>当你创建一个新的My解释器时,想出一个唯一的名字并将其放入哈希映射中;将该状态发送到另一个活动,只需将唯一的名称放入哈希映射中,当第二个活动开始了,它可以从哈希映射及其接收到的名称。

谢谢你的帮助,但我发现了一个可选的解决方案

 public class getsetclass implements Serializable {private int dt = 10;//pass any object, drwabalepublic 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());}

我也遇到过同样的问题。我通过使用静态类来解决它,将我想要的任何数据存储在HashMap中。在顶部,我使用了标准活动类的扩展,在那里我覆盖了onCreate an onDestroy方法来执行数据传输和数据清除隐藏。必须更改一些荒谬的设置,例如方向处理。

注释:不提供要传递给另一个活动的通用对象是件麻烦事。这就像开枪打自己的膝盖,希望赢得100米。“Parcant”不足以替代。它让我发笑……我不想在我的无技术API中实现这个接口,因为我不想引入一个新的层……怎么可能,我们在移动编程中离现代范式如此之远……

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

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

//receiveClassName model = (ClassName) getIntent().getSerializableExtra("Editing");
And
Class ClassName implements Serializable {}

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

<applicationandroid:name=".MyApplication"...

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

在第一个活动中:

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

在第二个活动中,执行:

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

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

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

你的类应该实现Serializable或Parcelable。

public class MY_CLASS implements Serializable

一旦完成,您可以在put Extra上发送一个对象

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

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

A.数据库

共同的偏好。

C.对象序列化。

一个可以保存公共数据的类可以被命名为通用工具,这取决于你。

通过意图和可包装的接口传递数据。

这取决于您的项目需求。

A.数据库

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

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

B.共享偏好

假设您想存储用户名。所以现在有两件事: Username, Value。

如何存储

 // Create an object of SharedPreferences.SharedPreferences sharedPref = PreferenceManager.getDefaultSharedPreferences(this);//now get EditorSharedPreferences.Editor editor = sharedPref.edit();//put your valueeditor.putString("userName", "stackoverlow");
//commits your editseditor.commit();

使用put String()、put Boolean()、put Int()、put Float()、putLong(),您可以保存所需的dtatype。

如何获取

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

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;}

}

使用以下命令在mail方法中设置变量

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

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

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

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

如果你想要一个教程来引用这个链接

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

在其他类中获取变量

D.常用工具

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

样本

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/

在你的第一个活动中:

intent.putExtra("myTag", yourObject);

在你的第二个:

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

不要忘记使您的自定义对象可序列化:

public class myCustomObject implements Serializable {...}

创建Android应用程序

文件>>新建>>Android应用

输入项目名称:android-pass-Object to活动

帕克凯奇:com.hmkcode.android

保留其他defualt选项,继续下一步直到你到达Finish

在开始创建App之前,我们需要创建POJO类“Person”,我们将使用它将对象从一个活动发送到另一个活动。请注意,该类正在实现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....
@Overridepublic 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" >
<LinearLayoutandroid:layout_width="fill_parent"android:layout_height="wrap_content"android:orientation="horizontal"><TextViewandroid:id="@+id/tvName"android:layout_width="100dp"android:layout_height="wrap_content"android:layout_gravity="center"android:gravity="center_horizontal"android:text="Name" />
<EditTextandroid:id="@+id/etName"android:layout_width="wrap_content"android:layout_height="wrap_content"
android:ems="10" ><requestFocus /></EditText></LinearLayout>
<LinearLayoutandroid:layout_width="fill_parent"android:layout_height="wrap_content"android:orientation="horizontal"><TextViewandroid:id="@+id/tvAge"android:layout_width="100dp"android:layout_height="wrap_content"android:layout_gravity="center"android:gravity="center_horizontal"android:text="Age" /><EditTextandroid:id="@+id/etAge"android:layout_width="wrap_content"android:layout_height="wrap_content"android:ems="10" /></LinearLayout>
<Buttonandroid: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">
<TextViewandroid: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;@Overrideprotected 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);}
@Overridepublic void onClick(View view) {
// 1. create an intent pass class name or intnet action nameIntent intent = new Intent("com.hmkcode.android.ANOTHER_ACTIVITY");
// 2. create person objectPerson person = new Person();person.setName(etName.getText().toString());person.setAge(Integer.parseInt(etAge.getText().toString()));
// 3. put person in intent dataintent.putExtra("person", person);
// 4. start the activitystartActivity(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;
@Overrideprotected void onCreate(Bundle savedInstanceState) {// TODO Auto-generated method stubsuper.onCreate(savedInstanceState);setContentView(R.layout.activity_another);
// 1. get passed intentIntent intent = getIntent();
// 2. get person object from intentPerson person = (Person) intent.getSerializableExtra("person");
// 3. get reference to person textViewtvPerson = (TextView) findViewById(R.id.tvPerson);
// 4. display name & age on textViewtvPerson.setText(person.toString());
}}
Intent i = new Intent();i.putExtra("name_of_extra", myParcelableObject);startACtivity(i);

如果您对使用putExtra功能不是很挑剔,只是想使用对象启动另一个活动,您可以查看我编写的GNLauncher(https://github.com/noxiouswinter/gnlib_android/wiki#gnlauncher)库,以尝试使此过程更加直接。

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

我知道这有点晚了,但是如果你只想为几个对象执行此操作,为什么不在目标活动中将对象声明为公共静态对象呢?

public static myObject = new myObject();

从你的源活动中给它一个值?

destinationActivity.myObject = this.myObject;

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

如果您有一个单例类(fx Service)充当模型层的网关,则可以通过在该类中使用带有getter和setter的变量来解决它。

在活动1中:

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

在活动2中:

private Service service;private Order order;
@Overrideprotected 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;}

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

在您的类模型(Object)中实现Serializable,用于示例:

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);

您的第二个活动(NewActive)

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

祝你好运!!

到目前为止,IMHO是包裹对象的最简单方法。您只需在您希望使其可包裹的对象上方添加一个注释标签。

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

@Parcelpublic 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; }}
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 stubreturn 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");

我使用Gson及其强大而简单的api在活动之间发送对象,

示例

// This is the object to be sent, can be any objectpublic class AndroidPacket {
public String CustomerName;
//constructorpublic 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 GsonAndroidPacket androidPacket = new AndroidPacket("Ahmad");String objAsJson = androidPacket.toJson();
Intent intent = new Intent(A.this, B.class);intent.putExtra("my_obj", objAsJson);startActivity(intent);

接收到B

@Overrideprotected void onCreate(Bundle savedInstanceState) {Bundle bundle = getIntent().getExtras();String objAsJson = bundle.getString("my_obj");AndroidPacket androidPacket = AndroidPacket.fromJson(objAsJson);
// Here you can use your ObjectLog.d("Gson", androidPacket.CustomerName);}

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

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

public class MyClass implements Serializable{
}

然后你可以传递给一个意图

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

为了得到它,你简单地打电话

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

使用谷歌的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 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 availableString defValue= new Gson().toJson(defObject);String jsonString=getIntent().getExtras().getString("example",defValue);//passed example objectExample exampleObject=new Gson().fromJson(jsonString,Example .class);

在gradle中添加此依赖项

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

在你的类中实现可序列化

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);

int第二个活动你可以得到这样的数据

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

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

POJO class”发布"(注意它是可序列化的)

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 class"评论"(由于是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(){@Overridepublic 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);
}});

在您的收件人类"评论活动"中,您可以获得以下数据

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

首先在你的类中实现可包裹。然后像这样传递对象。

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");

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

参考

通过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);

快速需求的简短答案

1.将您的类实现为可序列化。

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

public class SportsData implements  Serializablepublic 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");
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);
We can send data one Activty1 to Activity2 with multiple ways like.1- Intent2- bundle3- create an object and send through intent.................................................1 - Using intentPass the data through intentIntent intentActivity1 = new Intent(Activity1.this, Activity2.class);intentActivity1.putExtra("name", "Android");startActivity(intentActivity1);Get the data in Activity2 calssIntent intent = getIntent();if(intent.hasExtra("name")){String userName = getIntent().getStringExtra("name");}..................................................2- Using BundleIntent 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 calssIntent intent = getIntent();if(intent.hasExtra("name")){String userName = getIntent().getStringExtra("name");}..................................................3-  Put your Object into IntentIntent intentActivity1 = new Intent(Activity1.this, Activity2.class);intentActivity1.putExtra("myobject", myObject);startActivity(intentActivity1);Receive object in the Activity2 ClassIntent intent = getIntent();Myobject obj  = (Myobject) intent.getSerializableExtra("myobject");

在科尔廷

在build.gradle.中添加kotlin扩展

apply plugin: 'kotlin-android-extensions'
android {androidExtensions {experimental = true}}

然后像这样创建您的数据类。

@Parcelizedata 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")

最简单的java方法是:在pojo/model类中实现可序列化

推荐用于Android的性能视图:使模型可打包