¿Cómo enviar un objeto de una actividad de Android a otra usando Intents?

¿Cómo puedo pasar un objeto de un tipo personalizado de una Actividad a otra usando el método putExtra() de la clase Intención ?

Si solo está pasando objetos, entonces Parcelable fue diseñado para esto. Requiere un poco más de esfuerzo que utilizar la serialización nativa de Java, pero es mucho más rápido (y me refiero a manera, MUCHO más rápido).

De los documentos, un ejemplo simple de cómo implementar es:

 // 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 CREATOR = new Parcelable.Creator() { 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(); } } 

Observe que en el caso de que tenga más de un campo para recuperar de una Parcela determinada, debe hacerlo en el mismo orden en que los ingresó (es decir, en un enfoque FIFO).

Una vez que sus objetos implementen Parcelable , solo es cuestión de ponerlos en sus Intenciones con putExtra () :

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

Luego puede sacarlos de nuevo con getParcelableExtra () :

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

Si su Clase de objetos implementa Parcelable y Serializable, asegúrese de realizar una de las siguientes acciones:

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

Tendrá que serializar su objeto en algún tipo de representación de cadena. Una posible representación de cadenas es JSON, y una de las maneras más fáciles de serializar a / desde JSON en Android, si me preguntas, es a través de Google GSON .

En ese caso, juse puso el valor de retorno de la cadena (new Gson()).toJson(myObject); y recupera el valor de la cadena y usa fromJson para volver a convertirlo en tu objeto.

Sin embargo, si su objeto no es muy complejo, puede que no valga la pena la sobrecarga, y podría considerar pasar los valores separados del objeto en su lugar.

Puede enviar objetos serializables mediante bash

 // 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 { } 

Para situaciones en las que sabe que va a pasar datos dentro de una aplicación, use “globales” (como clases estáticas)

Esto es lo que Dianne Hackborn (hackbod – un ingeniero de software Android de Google) tenía que decir al respecto:

Para situaciones donde sabe que las actividades se están ejecutando en el mismo proceso, puede simplemente compartir datos a través de globales. Por ejemplo, podría tener un HashMap> global HashMap> y cuando crea un nuevo MyInterpreterState, debe tener un nombre único para él y ponerlo en el mapa hash; para enviar ese estado a otra actividad, simplemente ponga el nombre único en el mapa hash y cuando la segunda actividad se inicie, puede recuperar el MyInterpreterState del mapa hash con el nombre que recibe.

Tu clase debe implementar Serializable o Parcelable.

 public class MY_CLASS implements Serializable 

Una vez hecho esto, puede enviar un objeto en putExtra

 intent.putExtra("KEY", MY_CLASS_instance); startActivity(intent); 

Para obtener extras solo tienes que hacer

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

Si su clase implementa el uso Parcelable siguiente

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

Espero que ayude: D

si su clase de objeto implementa Serializable , no necesita hacer nada más, puede pasar un objeto serializable.
eso es lo que uso

Respuesta corta para una necesidad rápida

1. Implemente su Clase en Serializable.

¡Si tienes Clases internas, no olvides implementarlas en Serializable también!

 public class SportsData implements Serializable public class Sport implements Serializable List clickedObj; 

2. Pon tu objeto en el bash

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

3. Y recibe tu objeto en la otra clase de actividad

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

Puedes usar el BUNDLE de Android para hacer esto.

Crea un paquete de tu clase como:

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

Luego pasa este paquete con INTENCION. Ahora puedes recrear tu objeto de clase pasando paquete como

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

Declare esto en su clase personalizada y use.

Gracias por la ayuda plotble pero encontré una solución más opcional

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

En la actividad uno

 getsetclass d = new getsetclass (); d.setDt(50); LinkedHashMap obj = new LinkedHashMap(); 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); 

Obtener datos en la Actividad 2

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

implementar serializable en tu clase

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

Entonces puedes pasar este objeto a propósito

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

En la segunda actividad puede obtener datos como este

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

Pero cuando los datos se vuelven grandes, este método será lento.

Hay dos maneras en que puede acceder a variables u objetos en otras clases o actividades.

A. Base de datos

B. preferencias compartidas.

C. Serialización de objetos.

D. Una clase que puede contener datos comunes se puede nombrar como Utilidades comunes, depende de usted.

E. Pasar datos a través de Intentos e Interfaz Parcelable.

Depende de las necesidades de tu proyecto.

A. Base de datos

SQLite es una base de datos de código abierto que está integrada en Android. SQLite admite características de bases de datos relacionales estándar como syntax SQL, transacciones y declaraciones preparadas.

Tutoriales – http://www.vogella.com/articles/AndroidSQLite/article.html

B. Preferencias compartidas

Supongamos que desea almacenar el nombre de usuario. Así que ahora habrá dos cosas, un Nombre de usuario clave , Valor Valor.

Cómo almacenar

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

Usando putString (), putBoolean (), putInt (), putFloat (), putLong () puede guardar su tipo de dta deseado.

Cómo buscar

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

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

C. Serialización de objetos

La serlización de objetos se usa si queremos guardar un estado de objeto para enviarlo a través de la red o también puede usarlo para su propósito.

Use beans Java y almacénelo como uno de sus campos y use getters y setter para eso

Los JavaBeans son clases de Java que tienen propiedades. Piense en las propiedades como variables de instancia privadas. Dado que son privados, la única forma en que se puede acceder desde fuera de su clase es a través de los métodos en la clase. Los métodos que cambian el valor de una propiedad se llaman métodos setter, y los métodos que recuperan el valor de una propiedad se llaman métodos getter.

 public class VariableStorage implements Serializable { private String inString ; public String getInString() { return inString; } public void setInString(String inString) { this.inString = inString; } } 

Establezca la variable en su método de correo utilizando

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

Luego usa object Serialzation para serializar este objeto y en tu otra clase deserializar este objeto.

En la serialización, un objeto se puede representar como una secuencia de bytes que incluye los datos del objeto, así como información sobre el tipo del objeto y los tipos de datos almacenados en el objeto.

Después de escribir un objeto serializado en un archivo, se puede leer del archivo y deserializar, es decir, la información de tipo y los bytes que representan el objeto y sus datos se pueden usar para recrear el objeto en la memoria.

Si quieres un tutorial para esto, consulta este enlace

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

Obtener variable en otras clases

D. CommonUtilities

Puede crear una clase por su cuenta que pueda contener datos comunes que frecuentemente necesita en su proyecto.

Muestra

 public class CommonUtilities { public static String className = "CommonUtilities"; } 

E. Pasar datos a través de Intenciones

Por favor refiérase a este tutorial para esta opción de pasar datos.

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

Utilizo Gson con su api tan poderosa y simple para enviar objetos entre actividades,

Ejemplo

 // 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 funciones las agrega a los objetos que desea enviar

Uso

Enviar objeto de A 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); 

Recibir en 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); } 

Lo uso casi en todos los proyectos que hago y no tengo problemas de rendimiento.

Luché con el mismo problema. Lo resolví usando una clase estática, almacenando cualquier información que quisiera en un HashMap. En la parte superior utilizo una extensión de la clase de actividad estándar donde he anulado los métodos en Crear un onDestroy para hacer el transporte de datos y la eliminación de datos ocultos. Deben cambiarse algunas configuraciones ridículas, por ejemplo, la orientación.

Anotación: No proporcionar objetos generales para pasar a otra actividad es dolor en el trasero. Es como dispararse en la rodilla y esperar ganar 100 metros. “Parcable” no es un sustituto suficiente. Me hace reír … No quiero implementar esta interfaz con mi API sin tecnología, ya que menos quiero presentar una nueva capa … ¿Cómo podría ser que estamos en una progtwigción móvil tan lejos de paradigma moderno …

En tu primera actividad:

 intent.putExtra("myTag", yourObject); 

Y en tu segundo:

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

No olvides hacer que tu objeto personalizado sea serializable:

 public class myCustomObject implements Serializable { ... } 

Otra forma de hacerlo es usar el objeto Application (android.app.Application). Usted define esto en su archivo AndroidManifest.xml como:

  

A continuación, puede invocarlo desde cualquier actividad y guardar el objeto en la clase de Application .

En FirstActivity:

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

En SecondActivity, haz:

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

Esto es útil si tiene objetos que tienen un scope de nivel de aplicación, es decir, deben usarse en toda la aplicación. El método Parcelable es aún mejor si desea un control explícito sobre el scope del objeto o si el scope es limitado.

Sin embargo, esto evita el uso de Intents . No sé si te convienen. Otra forma en que utilicé esto es tener identificadores int de objetos enviados a través de bashs y recuperar objetos que tengo en Maps en el objeto Application .

en su modelo de clase (Objeto) implemente Serializable, por ejemplo:

 public class MensajesProveedor implements Serializable { private int idProveedor; public MensajesProveedor() { } public int getIdProveedor() { return idProveedor; } public void setIdProveedor(int idProveedor) { this.idProveedor = idProveedor; } } 

y tu primera actividad

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

y su segunda actividad (NewActivity)

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

¡¡buena suerte!!

 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 CREATOR = new Parcelable.Creator() { public SharedBooking createFromParcel(Parcel in) { return new SharedBooking(in); } public SharedBooking[] newArray(int size) { return new SharedBooking[size]; } }; } 

Pasando los datos:

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

Recuperando los datos:

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

la solución más fácil que encontré es … crear una clase con miembros de datos estáticos con getters setters.

establecer desde una actividad y obtener de otra actividad ese objeto.

actividad A

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

actividad b

 mytestclass obj= mytestclass.staticfunctionGet(); 

puede usar los métodos putExtra (Serializable ..) y getSerializableExtra () para pasar y recuperar objetos de su tipo de clase; Tendrás que marcar tu clase Serializable y asegurarte de que todas tus variables miembro sean serializables también …

Crea una aplicación para Android

Archivo >> Nuevo >> Aplicación de Android

Introduzca el nombre del proyecto: android-pass-object-to-activity

Pakcage: com.hmkcode.android

Mantenga otras selecciones de defualt, vaya a Next hasta llegar a Finish

Antes de comenzar a crear la aplicación, necesitamos crear la clase POJO “Persona” que usaremos para enviar objetos de una actividad a otra. Tenga en cuenta que la clase está implementando la interfaz 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 + "]"; } } 

Dos diseños para dos actividades

activity_main.xml

              

activity_another.xml

    

Dos clases de actividades

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

Sé que es tarde, pero es muy simple. Todo lo que tienes que hacer es dejar que tu clase implemente Serializable como

 public class MyClass implements Serializable{ } 

entonces puedes pasar a una intención como

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

Para obtenerlo, simplemente llama

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

Al usar la biblioteca Gson de Google, puede pasar el objeto a otras actividades. En realidad, convertiremos el objeto en la forma de cadena json y, después de pasar a otra actividad, volveremos a convertirlo a un objeto como este

Considera una clase de frijoles como esta

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

Necesitamos pasar el objeto de la clase Ejemplo

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

Para leer, necesitamos hacer la operación inversa en 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); 

Agregue esta dependencia en Gradle

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

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 have a singleton class (fx Service) acting as gateway to your model layer anyway, it can be solved by having a variable in that class with getters and setters for it.

In Activity 1:

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

In Activity 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. } 

In Service:

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

This solution does not require any serialization or other “packaging” of the object in question. But it will only be beneficial if you are using this kind of architecture anyway.

By far the easiest way IMHO to parcel objects. You just add an annotation tag above the object you wish to make plotble.

An example from the library is below 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; } } 

First implement Parcelable in your class. Then pass object like this.

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

REFERENCIA

Start another activity from this activity pass parameters via Bundle Object

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

Retrieve on another activity (YourActivity)

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

This is ok for simple kind data type. But if u want to pass complex data in between activity u need to serialize it first.

Here we have Employee Model

 class Employee{ private String empId; private int age; print Double salary; getters... setters... } 

You can use Gson lib provided by google to serialize the complex data like this

 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() { }.getType(); Employee selectedEmp = gson.fromJson(empStr, type); 

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.

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 commentList = new ArrayList(); 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 getCommentList() { return commentList; } public void setCommentList(List 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");