如何使用Intents从一个Android活动发送对象到另一个？
我如何使用类Intent的putExtra()方法将自定义types的对象从一个Activity传递到另一个Activity ？
如果你只是传递对象，那么Parcelable就是为此而devise的。 它比使用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(); } }
请注意，如果您有多个字段从给定的包裹中检索，则必须按照您放入的顺序（即采用FIFO方法）执行此操作。
一旦你的对象实现了Parcelable ， 只需要用putExtra（）把它们放到你的Intents中 ：
Intent i = new Intent(); i.putExtra("name_of_extra", myParcelableObject);
然后你可以用getParcelableExtra（）把它们拉出来：
Intent i = getIntent(); MyParcelable myParcelableObject = (MyParcelable) i.getParcelableExtra("name_of_extra");
如果你的对象类实现了Parcelable和Serializable，那么确保你input了以下内容之一：
i.putExtra("parcelable_extra", (Parcelable) myParcelableObject); i.putExtra("serializable_extra", (Serializable) myParcelableObject);
您需要将您的对象序列化为某种string表示forms。 一种可能的string表示forms是JSON，如果您问我，可以通过Google GSON在Android中序列化JSON的最简单方法之一 。
在这种情况下，你可以从(new Gson()).toJson(myObject);得到string返回值(new Gson()).toJson(myObject); 并检索string值，并使用fromJson将其返回到您的对象。
但是，如果你的对象不是很复杂，那么可能不值得花销，而是可以考虑传递对象的单独值。
你可以通过意图发送可序列化的对象
// 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 { }
对于你知道你将在应用程序中传递数据的情况，使用“全局variables”（比如静态类）
以下是Dianne Hackborn（Google Android软件工程师hackbod）在这个问题上所说的话：
对于您知道活动在同一过程中运行的情况，您可以通过全局分享数据。 例如，你可以有一个全局的
HashMap<String, WeakReference<MyInterpreterState>>，当你为MyInterpreterState创build一个唯一的名字并把它放在哈希映射中; 要将该状态发送到另一个活动，只需将唯一名称放入哈希映射中，并在第二个活动启动时，可以使用收到的名称从哈希映射中检索MyInterpreterState。
你的类应该实现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
如果你的对象类实现了Serializable ，你不需要做任何事情，你可以传递一个可序列化的对象。
这就是我使用的。
你可以使用android的BUNDLE来做到这一点。
从你的class级创build一个包，如：
public Bundle toBundle() { Bundle b = new Bundle(); b.putString("SomeKey", "SomeValue"); return b; }
然后通过这个捆绑INTENT。 现在你可以通过传递bundle来重新创build类对象
public CustomClass(Context _context, Bundle b) { context = _context; classMember = b.getString("SomeKey"); }
在你的Custom类中声明并使用它。
有几种方法可以访问其他类或Activity中的variables或对象。
A.数据库
B.共享喜好。
C.对象序列化。
D.一个能容纳普通数据的类可以被命名为Common Utilities它取决于你。
E.通过Intents和Parcelable接口传递数据。
这取决于你的项目需求。
A. 数据库
SQLite是embedded到Android的开源数据库。 SQLite支持标准的关系数据库function，如SQL语法，事务和预处理语句。
教程 – http://www.vogella.com/articles/AndroidSQLite/article.html
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
C. 对象序列化
如果我们想要保存一个对象状态来通过networking发送它，或者你也可以使用它，你也可以使用对象serlization。
使用java bean并将其作为其中一个字段存储，并为此使用getter和setter
JavaBeans是具有属性的Java类。 将属性看作私有实例variables。 由于他们是私人的，所以他们可以从课外访问的唯一途径就是通过课堂上的方法。 更改属性值的方法称为setter方法，检索属性值的方法称为getter方法。
public class VariableStorage implements Serializable { private String inString ; public String getInString() { return inString; } public void setInString(String inString) { this.inString = inString; } }
通过使用在邮件方法中设置variables
VariableStorage variableStorage = new VariableStorage(); variableStorage.setInString(inString);
然后使用对象Serialzation序列化这个对象，并在你的其他类反序列化这个对象。
在序列化过程中，一个对象可以表示为一个包含对象数据的字节序列，以及关于对象types和存储在对象中的数据types的信息。
序列化对象写入文件后，可以从文件中读取并反序列化，即可以使用表示对象及其数据的types信息和字节来重新创build内存中的对象。
如果你想要这个教程，请参考这个链接
http://javawithswaranga.blogspot.in/2011/08/serialization-in-java.html
在其他类中获取variables
D.共同事业
你可以通过自己创build一个能包含你在项目中经常需要的常用数据的类。
样品
public class CommonUtilities { public static String className = "CommonUtilities"; }
E. 通过意图传递数据
请参阅本教程以获取传递数据的选项。
感谢您的可parcelable帮助，但我发现了一个更多的可选解决scheme
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()); }
在你的类中实现可序列化
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();
诠释第二个活动，你可以得到这样的数据
Place place= (Place) getIntent().getSerializableExtra("PLACE");
但是当数据变大的时候，这个方法会很慢。
我也遇到了同样的问题。 我解决了它通过使用静态类，存储我想要在HashMap中的任何数据。 最重要的是，我使用了标准的Activity类的扩展，我在这里覆盖了方法onCreate onDestroy来隐藏数据传输和数据清除。 一些荒谬的设置必须改变，如方向处理。
注释：不提供一般对象传递给另一个活动是痛苦的屁股。 这就像在膝盖上自杀，希望赢得100米。 “Parcable”不是一个足够的替代品。 这让我大笑……我不想将这个接口实现到我的无技术API，因为我更less想要引入一个新的Layer …怎么可能呢，我们在移动编程中距离那么远现代范式
在您的第一个活动中：
intent.putExtra("myTag", yourObject);
而在你的第二个：
myCustomObject myObject = (myCustomObject) getIntent().getSerializableExtra("myTag");
不要忘记让你的自定义对象可串行化：
public class myCustomObject implements Serializable { ... }
我使用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); }
我几乎在每个项目中都使用它，而且我没有任何性能问题。
另一种方法是使用Application对象（android.app.Application）。 你在你的AndroidManifest.xml文件中定义这个为：
<application android:name=".MyApplication" ...
然后，您可以从任何活动中调用该对象，并将该对象保存到Application类。
在FirstActivity中：
MyObject myObject = new MyObject(); MyApplication app = (MyApplication) getApplication(); app.setMyObject(myObject);
在SecondActivity中，执行：
MyApplication app = (MyApplication) getApplication(); MyObject retrievedObject = app.getMyObject(myObject);
如果您有具有应用程序级别范围的对象，那么这很方便，即必须在整个应用程序中使用它们。 如果您希望显式控制对象范围或范围有限，则Parcelable方法仍然更好。
尽pipe如此，这完全避免了Intents的使用。 我不知道他们是否适合你。 另一种使用这种方式的方法是通过intent发送对象的int标识符，并检索我在Application对象中的Maps中的对象。
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");
在你的类模型（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);
和你的第二个活动（NewActivity）
MensajesProveedor mensajes = (MensajesProveedor)getIntent().getExtras().getSerializable("mensajes");
祝你好运！！
您可以使用putExtra（Serializable ..）和getSerializableExtra（）方法来传递和检索类types的对象; 你将不得不标记你的类Serializable，并确保你的所有成员variables也是可序列化的…
创buildAndroid应用程序
文件>>新build>> Android应用程序
input项目名称：android-pass-object-to-activity
Pakcage：com.hmkcode.android
保持其他defultselect，去下一个，直到你达到完成
在开始创build应用程序之前，我们需要创buildPOJO类“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.... @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）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()); } }
Intent i = new Intent(); i.putExtra("name_of_extra", myParcelableObject); startACtivity(i);
快速需要的简短答案
1.实现你的类来实现Serializable。
如果你有任何内部的类，不要忘记实现那个类到Serializable呢！
public class SportsData implements Serializable public class Sport implements Serializable List<Sport> clickedObj;
2.把你的对象的意图
Intent intent = new Intent(SportsAct.this, SportSubAct.class); intent.putExtra("sport", clickedObj); startActivity(intent);
3.接受把你的对象放在另一个Activity Class中
Intent intent = getIntent(); Sport cust = (Sport) intent.getSerializableExtra("sport");
如果你有一个singleton类（fx Service）作为你的模型层的网关，它可以通过在这个类中有一个getter和setter的variables来解决。
在活动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; }
该解决scheme不需要任何序列化或其他对所述对象的“包装”。 但是如果你正在使用这种架构，这将是有益的。
到目前为止，恕我直言，最简单的方法来包裹对象。 您只需在要作为可分段的对象上方添加注释标记。
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; } }
我知道这是迟了，但它非常简单。你所要做的就是让你的类实现Serializable
public class MyClass implements Serializable{ }
那么你可以传递给一个意图
Intent intent=...... MyClass obje=new MyClass(); intent.putExtra("someStringHere",obje);
为了得到它你简单的电话
MyClass objec=(MyClass)intent.getExtra("theString");
使用谷歌的Gson库，您可以传递对象到另一个活动。实际上，我们将以jsonstring的forms转换对象，并在传递给其他活动后，我们将再次重新转换为对象
考虑一个像这样的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'
首先在你的课堂上实施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");
The package string isn't necessary, just the string needs to be the same in both Activities
REFERENCE
the most easiest solution i found is.. to create a class with static data members with getters setters.
set from one activity and get from another activity that object.
activity A
mytestclass.staticfunctionSet("","",""..etc.);
activity b
mytestclass obj= mytestclass.staticfunctionGet();
The simplest would be to just use the following where the item is a string:
intent.putextra("selected_item",item)
For receiving:
String name = data.getStringExtra("selected_item");
If you are not very particular about using the putExtra feature and just want to launch another activity with objects, you can check out the GNLauncher ( https://github.com/noxiouswinter/gnlib_android/wiki#gnlauncher ) library I wrote in an attempt to make this process more straight forward.
GNLauncher makes sending objects/data to an Activity from another Activity etc as easy as calling a function in the Activity with the required data as parameters. It introduces type safety and removes all the hassles of having to serialize, attaching to the intent using string keys and undoing the same at the other end.
通过Bundle对象从这个活动传递参数开始另一个活动
Intent intent = new Intent(getBaseContext(), YourActivity.class); intent.putExtra("USER_NAME", "xyz@gmail.com"); startActivity(intent);
检索另一个活动（YourActivity）
String s = getIntent().getStringExtra("USER_NAME");
这对于简单types的数据types是可以的。 但是如果你想在活动之间传递复杂的数据，你需要首先序列化它。
这里我们有员工模型
class Employee{ private String empId; private int age; print Double salary; getters... setters... }
你可以使用google提供的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);
POJO class "Post " (Note that it is implemented 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 class "Comment" (Since being a member of Post class,it is also needed to implement the 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; } }
Then in your activity class, you can do as following to pass the object to another 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); } });
In your recipient class "CommentsActivity" you can get the data as the following
Post post =(Post)getIntent().getSerializableExtra("post");
