Implemente su clase con Serializable. Supongamos que esta es su clase de entidad:

import java.io.Serializable;

@SuppressWarnings("serial") //With this annotation we are going to hide compiler warnings
public class Deneme implements Serializable {

    public Deneme(double id, String name) {
        this.id = id;
        this.name = name;
    }

    public double getId() {
        return id;
    }

    public void setId(double id) {
        this.id = id;
    }

    public String getName() {
        return this.name;
    }

    public void setName(String name) {
        this.name = name;
    }

    private double id;
    private String name;
}

Estamos enviando el objeto llamado dene de la actividad X a la actividad Y. En algún lugar de la actividad X;

Deneme dene = new Deneme(4,"Mustafa");
Intent i = new Intent(this, Y.class);
i.putExtra("sampleObject", dene);
startActivity(i);

En la actividad Y estamos obteniendo el objeto.

Intent i = getIntent();
Deneme dene = (Deneme)i.getSerializableExtra("sampleObject");

Eso es todo.

• Usar variables estáticas globales no es una buena práctica de ingeniería de software.
• Convertir los campos de un objeto en tipos de datos primitivospuede ser un trabajo agitado.
• Usar serializable está bien, pero no es eficiente en el rendimiento en la plataforma Android.
• Parcelable está específicamente diseñado para Android y debes usarlo. Aquí hay un ejemplo simple: Pasar objetos personalizados entre Android actividades

Puede generar código parcelable para su clase usando este sitio.

Mientras llama a una actividad

Intent intent = new Intent(fromClass.this,toClass.class).putExtra("myCustomerObj",customerObj);

En toClass.java recibe la actividad por

Customer customerObjInToClass = getIntent().getExtras().getParcelable("myCustomerObj");

Por favor, asegúrese de que customer class implementa parcelable

public class Customer implements Parcelable {

    private String firstName, lastName, address;
    int age;

    /* all your getter and setter methods */

    public Customer(Parcel in ) {
        readFromParcel( in );
    }

    public static final Parcelable.Creator CREATOR = new Parcelable.Creator() {
        public LeadData createFromParcel(Parcel in ) {
            return new Customer( in );
        }

        public Customer[] newArray(int size) {
            return new Customer[size];
        }
    };


    @Override
    public void writeToParcel(Parcel dest, int flags) {

        dest.writeString(firstName);
        dest.writeString(lastName);
        dest.writeString(address);
        dest.writeInt(age);
    }

    private void readFromParcel(Parcel in ) {

        firstName = in .readString();
        lastName  = in .readString();
        address   = in .readString();
        age       = in .readInt();
    }

En mi experiencia hay tres soluciones principales, cada una con sus desventajas y ventajas:

1. Implementando Parcelable

2. Implementando Serializable

3. Usando una biblioteca liviana de bus de eventos de algún tipo (por ejemplo, EventBus de Greenrobot o Otto de Square)

Parcelable - rápido y estándar de Android, pero tiene un montón de código repetitivo y requiere cadenas codificadas para referencia al tirar valoriza la intent (no fuertemente tipeado).

Serializable - cerca de cero repetitivo, pero es el enfoque más lento y también requiere cadenas codificadas al extraer valores de la intención (no fuertemente tipeado).

Bus de Eventos - cero repetitivo, enfoque más rápido, y no requiere cadenas codificadas, pero sí requiere una dependencia adicional (aunque generalmente liviana, ~40 KB)

He publicado una comparación muy detallada alrededor estos tres enfoques, incluidos los parámetros de eficiencia.

Use gson para convertir su objeto a JSON y pasarlo a través de intent. En la nueva actividad, convierta el JSON en un objeto.

En su build.gradle, agregue esto a sus dependencias

implementation 'com.google.code.gson:gson:2.8.4'

En tu actividad, convierte el objeto a json-string:

Gson gson = new Gson();
String myJson = gson.toJson(vp);
intent.putExtra("myjson", myjson);

En su Actividad receptora, convierta la cadena json al objeto original:

Gson gson = new Gson();
YourObject ob = gson.fromJson(getIntent().getStringExtra("myjson"), YourObject.class);

Para Kotlin es lo mismo

Pasar los datos

val gson = Gson()
val intent = Intent(this, YourActivity::class.java)
intent.putExtra("identifier", gson.toJson(your_object))
startActivity(intent)

Recibir los datos

val gson = Gson()
val yourObject = gson.fromJson<YourObject>(intent.getStringExtra("identifier"), YourObject::class.java)

También puede escribir los datos del objeto en cadenas temporales e ints, y pasarlos a la actividad. Por supuesto, de esa manera, se obtienen los datos transportados, pero no el objeto en sí.

Pero si solo quieres mostrarlos, y no usar el objeto en otro método o algo así, debería ser suficiente. Lo hice de la misma manera para mostrar los datos de un objeto en otra actividad.

String fName_temp   = yourObject.getFname();
String lName_temp   = yourObject.getLname();
String age_temp     = yourObject.getAge();
String address_temp = yourObject.getAddress();

Intent i = new Intent(this, ToClass.class);
i.putExtra("fname", fName_temp);
i.putExtra("lname", lName_temp);
i.putExtra("age", age_temp);
i.putExtra("address", address_temp);

startActivity(i);

También puedes pasarlos directamente en lugar de los ivars temporales, pero de esta manera es más claro, en mi opinión. Además, puede establecer los ivars temporales en null para que el GarbageCollector los limpie antes.

¡Buena suerte!

En una nota al margen: sobreescriba toString() en lugar de escribir su propio método de impresión.

Como se menciona en los comentarios a continuación, así es como obtiene sus datos de vuelta en otra actividad:

String fName = getIntent().getExtras().getInt("fname");

Encontré un método simple y elegante:

• NO Parcelable
• NO Serializable
• NO Hay Campo Estático
• No Event Bus

Método 1

Código para la primera actividad:

    final Object objSent = new Object();
    final Bundle bundle = new Bundle();
    bundle.putBinder("object_value", new ObjectWrapperForBinder(objSent));
    startActivity(new Intent(this, SecondActivity.class).putExtras(bundle));        
    Log.d(TAG, "original object=" + objSent);

Código para la segunda actividad:

    final Object objReceived = ((ObjectWrapperForBinder)getIntent().getExtras().getBinder("object_value")).getData();
    Log.d(TAG, "received object=" + objReceived);

Encontrará objSent & objReceived tienen el mismo hashCode, por lo que son idénticos.

Pero ¿por qué podemos pasar un objeto java en este ¿camino?

En realidad, android binder creará una referencia JNI global para el objeto java y publicará esta referencia JNI global cuando no haya referencia para este objeto java. binder guardará esta referencia JNI global en el objeto Binder.

*PRECAUCIÓN: este método SOLO funciona a menos que las dos actividades se ejecuten en el mismo proceso, de lo contrario lanza ClassCastException a (ObjectWrapperForBinder)getIntent().getExtras().getBinder ("object_value") *

Clase ObjectWrapperForBinder defination

public class ObjectWrapperForBinder extends Binder {

    private final Object mData;

    public ObjectWrapperForBinder(Object data) {
        mData = data;
    }

    public Object getData() {
        return mData;
    }
}

Método 2

• para el remitente,
  1. use un método nativo personalizado para agregar su objeto java a la tabla de referencia global de JNI (a través de JNIEnv::NewGlobalRef)
  2. coloque el entero de retorno(en realidad, JNIEnv::NewGlobalRef return jobject, que es un puntero, podemos enviarlo a int de forma segura) a su Intent (a través de Intent::putExtra)
• para el receptor
  1. obtener entero desde Intent (a través de Intent:: getInt)
  2. use un método nativo personalizado para restaurar su objeto java desde la tabla de referencia global JNI (a través de JNIEnv::NewLocalRef)
  3. remove item from JNI global reference table (via JNIEnv:: DeleteGlobalRef),

Pero el Método 2 tiene un pequeño pero grave problema, si el receptor no puede restaurar el objeto java (por ejemplo, ocurre alguna excepción antes de restaurar el objeto java, o la Actividad del receptor no existe en absoluto), entonces el objeto java se convertirá en un huérfano o pérdida de memoria, Método 1 no tiene este problema, porque Android binder manejará esta excepción

Método 3

Para invocar el objeto java de forma remota, crearemos un contrato de datos / interfaz para describir el objeto java, usaremos el archivo aidl

IDataContract.aidl

package com.example.objectwrapper;
interface IDataContract {
    int func1(String arg1);
    int func2(String arg1);
}

Código para la primera actividad

    final IDataContract objSent = new IDataContract.Stub() {

        @Override
        public int func2(String arg1) throws RemoteException {
            // TODO Auto-generated method stub
            Log.d(TAG, "func2:: arg1=" + arg1);
            return 102;
        }

        @Override
        public int func1(String arg1) throws RemoteException {
            // TODO Auto-generated method stub
            Log.d(TAG, "func1:: arg1=" + arg1);
            return 101;
        }
    };
    final Bundle bundle = new Bundle();
    bundle.putBinder("object_value", objSent.asBinder());
    startActivity(new Intent(this, SecondActivity.class).putExtras(bundle));
    Log.d(TAG, "original object=" + objSent);

Código para la segunda actividad:

cambia el atributo android: process en AndroidManifest.xml a un archivo no vacío nombre del proceso para asegurarse de que la segunda actividad se ejecute en otro proceso

    final IDataContract objReceived = IDataContract.Stub.asInterface(getIntent().getExtras().getBinder("object_value"));
    try {
        Log.d(TAG, "received object=" + objReceived + ", func1()=" + objReceived.func1("test1") + ", func2()=" + objReceived.func2("test2"));
    } catch (RemoteException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

De esta manera, podemos pasar una interfaz entre dos actividades a pesar de que se ejecutan en un proceso diferente, y llamar al método de interfaz de forma remota

Método 4

El método 3 no parece lo suficientemente simple porque debemos implementar una interfaz aidl. Si solo quieres hacer una tarea simple y el valor de retorno del método es innecesario, podemos usar Android.operativo.Mensajero

Código para la primera actividad (remitente):

public class MainActivity extends Activity {
    private static final String TAG = "MainActivity";

    public static final int MSG_OP1 = 1;
    public static final int MSG_OP2 = 2;

    public static final String EXTRA_MESSENGER = "messenger";

    private final Handler mHandler = new Handler() {

        @Override
        public void handleMessage(Message msg) {
            // TODO Auto-generated method stub
            Log.e(TAG, "handleMessage:: msg=" + msg);
            switch (msg.what) {
            case MSG_OP1:

                break;
            case MSG_OP2:
                break;

            default:

                break;
            }
            super.handleMessage(msg);
        }

    };
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        startActivity(new Intent(this, SecondActivity.class).putExtra(EXTRA_MESSENGER, new Messenger(mHandler)));
    }
}

Código para la segunda actividad (receptor ):

public class SecondActivity extends Activity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_second);

        final Messenger messenger = getIntent().getParcelableExtra(MainActivity.EXTRA_MESSENGER);
        try {
            messenger.send(Message.obtain(null, MainActivity.MSG_OP1, 101, 1001, "10001"));
            messenger.send(Message.obtain(null, MainActivity.MSG_OP2, 102, 1002, "10002"));
        } catch (RemoteException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }
}

Todo el Mensajero.send se ejecutará en un Controlador de forma asíncrona y secuencial.

En realidad, androide.operativo.Messenger también es una interfaz aidl, si tienes el código fuente de Android, puedes encontrar un archivo llamado iMessenger.aidl

package android.os;

import android.os.Message;

/** @hide */
oneway interface IMessenger {
    void send(in Message msg);
}

He creado una clase auxiliar singleton que contiene objetos temporales.

public class IntentHelper {

    private static IntentHelper _instance;
    private Hashtable<String, Object> _hash;

    private IntentHelper() {
        _hash = new Hashtable<String, Object>();
    }

    private static IntentHelper getInstance() {
        if(_instance==null) {
            _instance = new IntentHelper();
        }
        return _instance;
    }

    public static void addObjectForKey(Object object, String key) {
        getInstance()._hash.put(key, object);
    }

    public static Object getObjectForKey(String key) {
        IntentHelper helper = getInstance();
        Object data = helper._hash.get(key);
        helper._hash.remove(key);
        helper = null;
        return data;
    }
}

En lugar de poner tus objetos dentro de Intent, usa IntentHelper:

IntentHelper.addObjectForKey(obj, "key");

Dentro de su nueva actividad, puede obtener el objeto:

Object obj = (Object) IntentHelper.getObjectForKey("key");

Tenga en cuenta que una vez cargado, el objeto se elimina para evitar referencias innecesarias.

Hay un par de formas por las 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 puede ser nombrada como Utilidades comunes. Depende de ti.

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

Depende de las necesidades de su proyecto.

A. Base de datos

SQLite es un abierto base de datos de origen que está incrustada en Android. SQLite admite funciones de base de datos relacionales estándar como sintaxis SQL, transacciones y declaraciones preparadas.

Tutoriales

B. Preferencias compartidas

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

Conservación de

 // 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 (), y putLong() puede guardar su dtatype deseado.

Cómo obtener

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 una red o también puede usarlo para su propósito.

Use Java beans y almacene en él como uno de sus campos y use getters y setter para que.

JavaBeans son clases Java que tienen propiedades. Piensa en propiedades como variables de instancia privada. Ya que son privados, la única manera se puede acceder a ellos desde fuera de su clase a través de 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 usando

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

Luego use object serialización para serializar este objeto y en su otra clase deserializar este objeto.

En la serialización, un objeto puede ser representado 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 que un objeto serializado ha sido escrito en un archivo, puede ser leído desde el archivo y deserializado. Es decir, la información de tipo y bytes que representan el objeto y sus datos se pueden utilizar para recrear el objeto en la memoria.

Si desea tutorial para esto consulte:

• Serialización en Java (blog post)

• Obtener variable en otras clases (Desbordamiento de pila)

D. Usos comunes

Puede crear una clase por sí mismo que puede contener datos comunes que con frecuencia necesita en su proyecto.

Muestra

public class CommonUtilities {

    public static String className = "CommonUtilities";

}

E. Pasando datos a través de intentos

Por favor, consulte el tutorial Android - Datos de paquetes para pasar entre Actividades usando clases parcelables para esta opción de pasar datos.

La mejor manera es tener una clase (llamada Control) en su aplicación que contenga una variable estática de tipo 'Customer' (en su caso). Inicializa la variable en tu actividad A.

Por ejemplo:

Control.Customer = CustomerClass;

Luego vaya a la Actividad B y tráigala de la clase Control. No olvide asignar un null después de usar la variable, de lo contrario la memoria se desperdiciará.

public class MyClass implements Serializable{
    Here is your instance variable
}

Ahora desea pasar el objeto de esta clase en startActivity. Simplemente use esto:

Bundle b = new Bundle();
b.putSerializable("name", myClassObject);
intent.putExtras(b);

Esto funciona aquí porque MyClass implementa Serializable.

Crea tu propia clase Customer de la siguiente manera:

import import java.io.Serializable;
public class Customer implements Serializable
{
    private String name;
    private String city;

    public Customer()
    {

    }
    public Customer(String name, String city)
    {
        this.name= name;
        this.city=city;
    }
    public String getName() 
    {
        return name;
    }
    public void setName(String name) 
    {
        this.name = name;
    }
    public String getCity() 
    {
        return city;
    }
    public void setCity(String city) 
    {
        this.city= city;
    }

}

En su método onCreate()

@Override
protected void onCreate(Bundle savedInstanceState) 
{
    super.onCreate(savedInstanceState); 
    setContentView(R.layout.activity_top);

    Customer cust=new Customer();
    cust.setName("abc");
    cust.setCity("xyz");

    Intent intent=new Intent(abc.this,xyz.class);
    intent.putExtra("bundle",cust);
    startActivity(intent); 
}

En la clase xyz activity debe usar el siguiente código:

Intent intent=getIntent();
Customer cust=(Customer)intent.getSerializableExtra("bundle");
textViewName.setText(cust.getName());
textViewCity.setText(cust.getCity());

Si elige usar la forma en que Samuh describe, recuerde que solo se pueden enviar valores primitivos. Es decir, valores que son parcables. Por lo tanto, si su objeto contiene objetos complejos, estos no seguirán. Por ejemplo, variables como Bitmap, HashMap, etc... Estos son difíciles de pasar por la intención.

En general, le aconsejaría que envíe solo tipos de datos primitivos como extras, como String, int, boolean, etc. En su caso sería: String fname, String lname, int age, y String address.

Mi opinión: Más los objetos complejos se comparten mejor implementando un ContentProvider, SDCard , etc. También es posible usar una variable estática , pero esto puede conducir rápidamente a código propenso a errores...

Pero de nuevo, es solo mi opinión subjetiva.

Estoy usando parcelable para enviar datos de una actividad a otra acivity. Aquí está mi código que funciona bien en mi proyecto.

public class Channel implements Serializable, Parcelable {

    /**  */
    private static final long serialVersionUID = 4861597073026532544L;

    private String cid;
    private String uniqueID;
    private String name;
    private String logo;
    private String thumb;


    /**
     * @return The cid
     */
    public String getCid() {
        return cid;
    }

    /**
     * @param cid
     *     The cid to set
     */
    public void setCid(String cid) {
        this.cid = cid;
    }

    /**
     * @return The uniqueID
     */
    public String getUniqueID() {
        return uniqueID;
    }

    /**
     * @param uniqueID
     *     The uniqueID to set
     */
    public void setUniqueID(String uniqueID) {
        this.uniqueID = uniqueID;
    }

    /**
     * @return The name
     */
    public String getName() {
        return name;
    }

    /**
     * @param name
     *            The name to set
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * @return the logo
     */
    public String getLogo() {
        return logo;
    }

    /**
     * @param logo
     *     The logo to set
     */
    public void setLogo(String logo) {
        this.logo = logo;
    }

    /**
     * @return the thumb
     */
    public String getThumb() {
        return thumb;
    }

    /**
     * @param thumb
     *     The thumb to set
     */
    public void setThumb(String thumb) {
        this.thumb = thumb;
    }


    public Channel(Parcel in) {
        super();
        readFromParcel(in);
    }

    public static final Parcelable.Creator<Channel> CREATOR = new Parcelable.Creator<Channel>() {
        public Channel createFromParcel(Parcel in) {
            return new Channel(in);
        }

        public Channel[] newArray(int size) {

            return new Channel[size];
        }
    };

    public void readFromParcel(Parcel in) {
        String[] result = new String[5];
        in.readStringArray(result);

        this.cid = result[0];
        this.uniqueID = result[1];
        this.name = result[2];
        this.logo = result[3];
        this.thumb = result[4];
    }

    public int describeContents() {
        return 0;
    }

    public void writeToParcel(Parcel dest, int flags) {

        dest.writeStringArray(new String[] { this.cid, this.uniqueID,
                this.name, this.logo, this.thumb});
    }
}

En ActivityA úsalo así:

Bundle bundle = new Bundle();
bundle.putParcelableArrayList("channel",(ArrayList<Channel>) channels);
Intent intent = new Intent(ActivityA.this,ActivityB.class);
intent.putExtras(bundle);
startActivity(intent);

En ActivityB úsalo así para obtener datos:

Bundle getBundle = this.getIntent().getExtras();
List<Channel> channelsList = getBundle.getParcelableArrayList("channel");

Puedes intentar usar esa clase. La limitación es que no se puede utilizar fuera de un proceso.

Una actividad:

 final Object obj1 = new Object();
 final Intent in = new Intent();
 in.putExtra(EXTRA_TEST, new Sharable(obj1));

Otra actividad:

final Sharable s = in.getExtras().getParcelable(EXTRA_TEST);
final Object obj2 = s.obj();

public final class Sharable implements Parcelable {

    private Object mObject;

    public static final Parcelable.Creator < Sharable > CREATOR = new Parcelable.Creator < Sharable > () {
        public Sharable createFromParcel(Parcel in ) {
            return new Sharable( in );
        }


        @Override
        public Sharable[] newArray(int size) {
            return new Sharable[size];
        }
    };

    public Sharable(final Object obj) {
        mObject = obj;
    }

    public Sharable(Parcel in ) {
        readFromParcel( in );
    }

    Object obj() {
        return mObject;
    }


    @Override
    public int describeContents() {
        return 0;
    }


    @Override
    public void writeToParcel(final Parcel out, int flags) {
        final long val = SystemClock.elapsedRealtime();
        out.writeLong(val);
        put(val, mObject);
    }

    private void readFromParcel(final Parcel in ) {
        final long val = in .readLong();
        mObject = get(val);
    }

    /////

    private static final HashMap < Long, Object > sSharableMap = new HashMap < Long, Object > (3);

    synchronized private static void put(long key, final Object obj) {
        sSharableMap.put(key, obj);
    }

    synchronized private static Object get(long key) {
        return sSharableMap.remove(key);
    }
}

Creta una clase como bean class e implementa la interfaz Serializable. Luego podemos pasarlo a través del método intent, por ejemplo:

intent.putExtra("class", BeanClass);

Luego obtenerlo de la otra actividad, por ejemplo:

BeanClass cb = intent.getSerializableExtra("class");

Crea dos métodos en tu clase personalizada como este

public class Qabir {

    private int age;
    private String name;

    Qabir(){
    }

    Qabir(int age,String name){
        this.age=age; this.name=name;
    }   

    // method for sending object
    public String toJSON(){
        return "{age:" + age + ",name:\"" +name +"\"}";
    }

    // method for get back original object
    public void initilizeWithJSONString(String jsonString){

        JSONObject json;        
        try {
            json =new JSONObject(jsonString );
            age=json.getInt("age");
            name=json.getString("name");
        } catch (JSONException e) {
            e.printStackTrace();
        } 
    }
}

Ahora en tu actividad de remitente haz así

Qabir q= new Qabir(22,"KQ");    
Intent in=new Intent(this,SubActivity.class);
in.putExtra("obj", q.toJSON());
startActivity( in);

Y en la Actividad del receptor

Qabir q =new Qabir();
q.initilizeWithJSONString(getIntent().getStringExtra("obj"));

Inicie otra actividad desde esta actividad y pase parámetros a través del Objeto Bundle

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

Recuperar datos de otra actividad (su actividad)

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

Esto está bien para el tipo simple de tipo de datos. Pero si u desea pasar datos complejos entre la actividad. U necesita serializarlo primero.

Aquí tenemos el Modelo de Empleado

class Employee{
    private String empId;
    private int age;
    print Double salary;

    getters...
    setters...
}

Puede utilizar Gson lib proporcionada por Google para serializar los datos complejos así

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

Esta pregunta también se discute en otra pregunta de desbordamiento de pila. Por favor, eche un vistazo a una solución para Pasar datos a través de intent usando Serializable. El punto principal es sobre el uso de Bundle objeto que almacena los datos necesarios dentro de Intent.

 Bundle bundle = new Bundle();

 bundle.putSerializable(key1, value1);
 bundle.putSerializable(key2, value2);
 bundle.putSerializable(key3, value3);

 intent.putExtras(bundle);

Para extraer valores:

 Bundle bundle = new Bundle();

 for (String key : bundle.keySet()) {
 value = bundle.getSerializable(key));
 }

La ventaja de Serializable es su simplicidad. Sin embargo, debe considerar usar el método Parcelable si necesita transferir muchos datos, porque Parcelable está diseñado específicamente para Android y es más eficiente que Serializable. Puedes crear la clase Parcelable usando:

1. una herramienta en línea - parcelabler
2. un plugin para Android Studio - Generador de código parcelable Android

Sí, usar un objeto estático es, con mucho, la forma más fácil de hacer esto con objetos personalizados no serializables.

Los objetos de actividad de Android se pueden destruir y reconstituir. Por lo tanto, tendrá que utilizar otro enfoque para mirar ellos - o cualquier objeto que crean!!! - hasta. Es decir, podría pasar como referencia de clase estática, pero luego el identificador de objeto (Java llama a estas "referencias", al igual que SmallTalk; pero no son referencias en el sentido de C o ensamblado) será posiblemente inválido más tarde porque una "característica" de Android OE es que cualquier Actividad puede ser aniquilada y reconstituida más tarde.

El la pregunta original se preguntó" Cómo pasar un objeto de una actividad a otra en Android " y nadie ha respondido a eso. Por supuesto, puede serializado (Serializable, Parcelable, a / desde JSON) y pasar una copia de los datos del objeto y se podría crear un nuevo objeto con los mismos datos; pero NO tendrá las mismas referencias/manejadores. Además, muchos otros mencionaron que puede almacenar la referencia en una tienda estática. Y eso funcionará a menos que Android decida onDestroy su Actividad.

Así, a realmente resolver la pregunta original que necesitaría una búsqueda estática más cada objeto actualizará su referencia cuando / si se vuelve a crear. Por ejemplo, cada actividad de Android se volvería a listar si se llama a su onCreate. También puedes ver cómo algunas personas usan la lista de tareas para buscar una actividad por nombre. (el sistema está destruyendo temporalmente esta instancia de la actividad para ahorrar espacio..getRunningTasks, la lista de tareas es efectivamente una lista especializada de la instancia de objeto más reciente de cada Actividad).

Para referencia:

Detenido: "La actividad está completamente oscurecida por otra actividad (la actividad está ahora en el "fondo"). Una actividad detenida también está viva (el objeto de actividad se conserva en la memoria, mantiene toda la información de estado y miembro, pero no se adjunta al gestor de ventanas). Sin embargo, ya no es visible para el usuario y puede ser asesinado por el sistema cuando se necesita memoria en otro lugar."

OnDestroy "system is temporarily destroying this instance of the activity to save space."

Entonces, el Bus de mensajes es una solución viable. Básicamente "puntea". En lugar de tratar de tener referencias a objetos, entonces usted rediseñe su diseño para usar MessagePassing en lugar de SequentialCode. Exponencialmente más difícil de depurar; pero le permite ignorar este tipo de entendimientos del entorno operativo. Efectivamente, cada acceso de método de objeto se invierte para que el llamante publique un Mensaje y el el objeto mismo define un manejador para ese mensaje. Mucho más código, pero puede hacerlo robusto con las restricciones de Android OE.

Si todo lo que desea es la Actividad superior (cosa típica en las aplicaciones de Android debido a que se necesita "Contexto" en todas partes), entonces puede hacer que cada Actividad se enumere como "superior" en el espacio global estático cada vez que se llame a su onResume. Entonces tu AlertDialog o lo que sea que necesite un contexto puede agarrarlo desde allí. Además, es un poco asqueroso usar un global pero puede simplificar el paso de un Contexto hacia arriba y hacia abajo en todas partes y, por supuesto, cuando se utiliza un MessageBus entonces ES global de todos modos.

1. Sé que la estática es mala, pero parece que nos vemos obligados a usarla aquí. El problema con parceables / seriazables es que las dos actividades tienen instancias duplicadas del mismo objeto = desperdicio de memoria y CPU.

   public class IntentMailBox {
       static Queue<Object> content = new LinkedList<Object>();
   }
   

Llamando a la actividad

IntentMailBox.content.add(level);
Intent intent = new Intent(LevelsActivity.this, LevelActivity.class);
startActivity(intent);

Actividad llamada (tenga en cuenta que onCreate () y onResume () pueden ser llamados varias veces cuando el sistema destruye y recrea actividades)

if (IntentMailBox.content.size()>0)
    level = (Level) IntentMailBox.content.poll();
else
    // Here you reload what you have saved in onPause()

1. Otra forma es declarar un campo estático de la clase que desea pasar en la misma clase. Solo servirá para este propósito. No olvide que puede ser null en onCreate, porque su paquete de aplicación ha sido descargado de la memoria por el sistema y recargado más tarde.

2. Teniendo en cuenta que aún necesita manejar el ciclo de vida de la actividad, es posible que desee escribir todos los datos directamente en las preferencias compartidas, lo que resulta doloroso con estructuras de datos complejas como lo es.

Respuestas anteriores casi todas correctas, pero para aquellos que no undestand esas respuestas Android tiene potente clase Intent con la ayuda de ella se comparten datos entre no solo la actividad, sino otros componentes de Android (receptor broadcasr, servicios para el contenido proporcionan que utilizamos ContetnResolver clase sin Intent). En tu actividad construyes intención

Intent intent = new Intent(context,SomeActivity.class);
intent.putExtra("key",value);
startActivity(intent);

En tu actividad de receving tienes

public class SomeActivity extends AppCompactActivity {

    public void onCreate(...){
    ...
          SomeObject someObject = getIntent().getExtras().getParceable("key");
    }

}

Debe implementar una interfaz Parcelable o Serializable en su objeto en para compartir entre actividades. Es difícil implementar Parcealbe en lugar de Serializable interfaz en el objeto es por eso que Android tiene plugin especialmente para esto.Descargar y utilizarlo

Siempre me había preguntado por qué esto no puede ser tan simple como llamar a un método de la otra actividad. Recientemente escribí una biblioteca de utilidades que lo hace casi tan simple como eso. Puedes comprobarlo aquí ( https://github.com/noxiouswinter/gnlib_android/wiki/gnlauncher).

GNLauncher hace que enviar objetos/datos a una Actividad desde otra Actividad, etc., sea tan fácil como llamar a una función en esa Actividad con los datos requeridos como parámetros. Introduce el tipo seguridad y elimina todas las prisas de tener que serializar, adjuntando a la intent usando teclas de cadena y deshaciendo la misma en el otro extremo.

Uso

Defina una interfaz con los métodos que desea llamar a la Actividad para iniciar.

public interface IPayload {
    public void sayHello(String name, int age);
}

Implementar la interfaz anterior en la Actividad a iniciar. También notifique a GNLauncher cuando la actividad esté lista.

public class Activity_1 extends Activity implements IPayload {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        //Notify GNLauncher when the Activity is ready. 
        GNLauncher.get().ping(this);
    }

    @Override
    public void sayHello(String name, int age) {
        Log.d("gnlib_test", "Hello " + name + "! \nYour age is: " + age);
    }
}

En la otra actividad, obtenga un proxy para la Actividad anterior y llame a cualquier método con el parámetros.

public class Activity_2 extends Activity {
    public void onClick(View v) {
        ((IPayload)GNLauncher.get().getProxy(this, IPayload.class, Activity_1.class)).sayHello(name, age);
    }
}

Se iniciará la primera actividad y se llamará al método con los parámetros requeridos.

Requisitos previos

Por favor refiérase a https://github.com/noxiouswinter/gnlib_android/wiki#prerequisites para obtener información sobre cómo agregar las dependencias.

Pasar objeto de una actividad a otra actividad.

(1) actividad de la fuente

Intent ii = new Intent(examreport_select.this,
                    BarChartActivity.class);

            ii.putExtra("IntentExamResultDetail",
                    (Serializable) your List<ArraList<String>> object here);
            startActivity(ii);

(2) actividad de destino

List<ArrayList<String>> aa = (List<ArrayList<String>>) getIntent()
            .getSerializableExtra("IntentExamResultDetail");

Solía establecer objeto con Pacelable o Serializable para transferir, pero cada vez que agrego otras variables a objeto(modelo), tengo que registrarlo todo. Es tan nconveniente.

Es súper fácil transferir objetos entre actividades o fragmentos.

Android DataCache

Podemos pasar el objeto de una actividad a otra actividad:

SupplierDetails poSuppliersDetails = new SupplierDetails();

Dentro de poSuppliersDetails tenemos algunos valores. Ahora estoy enviando este objeto a la actividad objetivo:

Intent iPODetails = new Intent(ActivityOne.this, ActivityTwo.class);
iPODetails.putExtra("poSuppliersDetails", poSuppliersDetails);

Cómo obtener esto en Actividadtwo:

private SupplierDetails supplierDetails;
    supplierDetails =(SupplierDetails) getIntent().getSerializableExtra("poSuppliersDetails");

Pasar una actividad a otra:

startActivity(new Intent(getBaseContext(),GetActivity.class).putExtra("passingkey","passingvalue"));

Obtener valores:

String myvalue= getIntent().getExtras("passingkey");

Hola a todos Veo un montón de buenas opciones, pero me preguntaba por qué No se ha utilizado la unión?

Pasar una referencia a un objeto me parece más eficiente que serializar y desterilizar objetos, pero no he hecho una inmersión profunda para ver si eso es lo que está pasando detrás de escena.

Crear una carpeta es bastante simple...

public class MyBinder extends Binder {

    private Object myObject;

    public MyBinder(Object object) {
        myObject = object;
    }

    public Object getObject() {
        return myObject;
    }

}

Y crear el parcelable para usarlo no es tan malo éter.

public class MyParcelable implements Parcelable {

    private Object myObject;

    public MyParcelable() {
    }

    public MyParcelable(Parcel parcel) {
        myObject = ((MyBinder)parcel.readStrongBinder()).getObject();
    }

    public void setObject(Object object) {
        myObject = object;
    }

    public Object getObject() {
        return myObject;
    }

    public void writeToParcel(Parcel parcel, int flags) {
        parcel.writeStrongBinder(new MyBinder(myObject));
    }

    public int describeContents() {
        return myObject == null ? 0 : 1;
    }

    public static final Parcelable.Creator<MyParcelable> CREATOR = new Parcelable.Creator<MyParcelable>() {

        public MyParcelable createFromParcel(Parcel parcel) {
            return new MyParcelable(parcel);
        }

        public MyParcelable[] newArray(int length) {
            return new MyParcelable[length];
        }

    };
}

Esta lógica es realmente genial porque en realidad están pasando una referencia de una actividad a otra.

Yo aconsejaría comprobar si hay nulos y si la instancia de Binder es MyBinder!

Y para implementar esto solo...

Envíalo

Object myObject = "some object";
MyParcelable myParcelable = new MyParcelable();
myParcelable.setObject(myObject);

intent.putExtra("MyParcelable", myParcelable);

Recuperarlo

myParcelable = (MyParcelable) getIntent().getExtras().getParcelable("MyParcelable");
myObject = myParcelable.getObject();

Diablos, alguien podría volverse loco y hacer de este lechón un verdadero genérico.