Tengo una actividad que es la actividad principal utilizada en toda la aplicación y tiene una serie de variables. Tengo otras dos actividades que me gustaría poder utilizar los datos de la primera actividad. Ahora sé que puedo hacer algo como esto:

GlobalState gs = (GlobalState) getApplication();
String s = gs.getTestMe();

Sin embargo, quiero compartir muchas variables y algunas pueden ser bastante grandes, así que no quiero crear copias de ellas como se indicó anteriormente.

¿Hay alguna manera de obtener y cambiar directamente las variables sin usar los métodos get y set? Recuerdo haber leído un artículo en el sitio de desarrollo de Google que decía que no se recomienda para el rendimiento en Android.

Aquí una compilación de las formas más comunes para lograr esto :

• Enviar datos dentro de la intención
• Campos estáticos
• HashMapa de WeakReferences
• Objetos persistentes (sqlite, compartir preferencias, archivo, etc.)

TL; DR : hay dos formas de compartir datos: pasar datos en los extras del intento o guardarlos en otro lugar. Si los datos son primitivos, cadenas u objetos definidos por el usuario: envíelos como parte de la intención extras (los objetos definidos por el usuario deben implementarse Parcelable). Si pasa objetos complejos, guarde una instancia en un singleton en otro lugar y acceda a ellos desde la actividad iniciada.

Algunos ejemplos de cómo y por qué implementar cada enfoque:

Enviar datos dentro de intentos

Intent intent = new Intent(FirstActivity.this, SecondActivity.class);
intent.putExtra("some_key", value);
intent.putExtra("some_other_key", "a value");
startActivity(intent);

En la segunda actividad:

Bundle bundle = getIntent().getExtras();
int value = bundle.getInt("some_key");
String value2 = bundle.getString("some_other_key");

Use este método si está pasando datos primitivos o cadenas . También puede pasar objetos que implemente Serializable.

Aunque es tentador, debe pensarlo dos veces antes de usarlo Serializable: es propenso a errores y es terriblemente lento. Entonces, en general: manténgase alejado deSerializable si es posible. Si desea pasar objetos complejos definidos por el usuario, eche un vistazo a la Parcelableinterfaz . Es más difícil de implementar, pero tiene considerables ganancias de velocidad en comparación Serializable.

Comparta datos sin persistir en el disco

Es posible compartir datos entre actividades guardándolos en la memoria dado que, en la mayoría de los casos, ambas actividades se ejecutan en el mismo proceso.

Nota: a veces, cuando el usuario abandona su actividad (sin abandonarla), Android puede decidir eliminar su aplicación. En tal escenario, he experimentado casos en los que Android intenta iniciar la última actividad utilizando la intención proporcionada antes de que la aplicación fuera eliminada. En estos casos, los datos almacenados en un singleton (ya sea el suyo oApplication ) desaparecerán y podrían ocurrir cosas malas. Para evitar estos casos, puede conservar los objetos en el disco o verificar los datos antes de usarlos para asegurarse de que sean válidos.

Usa una clase singleton

Tener una clase para guardar los datos:

public class DataHolder {
  private String data;
  public String getData() {return data;}
  public void setData(String data) {this.data = data;}

  private static final DataHolder holder = new DataHolder();
  public static DataHolder getInstance() {return holder;}
}

De la actividad lanzada:

String data = DataHolder.getInstance().getData();

Usar aplicación singleton

La aplicación singleton es una instancia de la android.app.Applicationcual se crea cuando se inicia la aplicación. Puede proporcionar uno personalizado extendiendo Application:

import android.app.Application;
public class MyApplication extends Application {
  private String data;
  public String getData() {return data;}
  public void setData(String data) {this.data = data;}
}

Antes de lanzar la actividad:

MyApplication app = (MyApplication) getApplicationContext();
app.setData(someData);

Luego, desde la actividad lanzada:

MyApplication app = (MyApplication) getApplicationContext();
String data = app.getData();

Campos estáticos

La idea es básicamente la misma que el singleton, pero en este caso proporciona acceso estático a los datos:

public class DataHolder {
  private static String data;
  public static String getData() {return data;}
  public static void setData(String data) {DataHolder.data = data;}
}

De la actividad lanzada:

String data = DataHolder.getData();

HashMapa de WeakReferences

La misma idea, pero permitiendo que el recolector de basura elimine objetos sin referencia (por ejemplo, cuando el usuario abandona la actividad):

public class DataHolder {
  Map<String, WeakReference<Object>> data = new HashMap<String, WeakReference<Object>>();

  void save(String id, Object object) {
    data.put(id, new WeakReference<Object>(object));
  }

  Object retrieve(String id) {
    WeakReference<Object> objectWeakReference = data.get(id);
    return objectWeakReference.get();
  }
}

Antes de lanzar la actividad:

DataHolder.getInstance().save(someId, someObject);

De la actividad lanzada:

DataHolder.getInstance().retrieve(someId);

Puede o no tener que pasar la identificación del objeto usando los extras del intento. Todo depende de tu problema específico.

Persistir objetos en el disco

La idea es guardar los datos en el disco antes de iniciar la otra actividad.

Ventajas: puede iniciar la actividad desde otros lugares y, si los datos ya persisten, debería funcionar bien.

Desventajas es engorroso y lleva más tiempo implementarlo. Requiere más código y, por lo tanto, más posibilidades de introducir errores. También será mucho más lento.

Algunas de las formas de persistir objetos incluyen:

• Guárdelos en las preferencias compartidas.
• Guárdelos en una base de datos sqlite
• Guárdelos en un archivo (evitaría este)

Lo que puedes usar:

1. pasar datos entre actividades (como dijo Cristian)
2. usando una clase con muchas variables estáticas (para que pueda llamarlas sin una instancia de la clase y sin usar getter / setter)
3. Usando una base de datos
4. Preferencias compartidas

Lo que elijas depende de tus necesidades. Probablemente usará más de una forma cuando tenga "mucho"

¡Haz lo que Google te ordena hacer! aquí: http://developer.android.com/resources/faq/framework.html#3

• Tipos de datos primitivos
• Objetos no persistentes
• Clase Singleton - mi favorita: D
• Un campo / método estático público
• Un hashmap de referencias débiles a objetos
• Objetos persistentes (preferencias de aplicación, archivos, proveedores de contenido, SQLite DB)

"Sin embargo, quiero compartir muchas variables y algunas podrían ser bastante grandes, así que no quiero crear copias de ellas como se indicó anteriormente".

Eso no hace una copia (especialmente con String , pero incluso los objetos se pasan por el valor de la referencia, no el objeto en sí, y los getters como ese están bien para usar, posiblemente mejor que otros medios porque son comunes y bien entendido). Los "mitos de rendimiento" más antiguos, como no usar getters y setters, todavía tienen algún valor, pero también se han actualizado en los documentos .

Pero si no quiere hacer eso, también puede hacer que las variables sean públicas o protegidas en GlobalState y acceder a ellas directamente. Y puede hacer un singleton estático como indica el objeto de aplicación JavaDoc :

Normalmente no hay necesidad de subclase Aplicación. En la mayoría de las situaciones, los singletons estáticos pueden proporcionar la misma funcionalidad de una manera más modular. Si su singleton necesita un contexto global (por ejemplo, para registrar receptores de difusión), la función para recuperarlo puede recibir un Context que internamente usa Context.getApplicationContext () cuando construye el singleton por primera vez.

El uso de datos de intención , como otras respuestas aquí señalan, es otra forma de pasar datos, pero generalmente se usa para datos más pequeños y tipos simples. Puede pasar datos más grandes / más complejos, pero es más complicado que simplemente usar un singleon estático. Sin embargo, el objeto Aplicación sigue siendo mi favorito personal para compartir datos no persistentes más grandes / complejos entre los componentes de la aplicación de Android (porque tiene un ciclo de vida bien definido en una aplicación de Android).

Además, como otros han señalado, si los datos se vuelven muy complejos y necesitan ser persistentes , puede usar SQLite o el sistema de archivos también.

Puede extender la clase de aplicación y etiquetar cualquier objeto que desee allí, luego estarán disponibles en cualquier lugar de su aplicación

Hay una nueva y mejor manera de compartir datos entre actividades, y es LiveData . Observe en particular esta cita de la página del desarrollador de Android:

El hecho de que los objetos LiveData sean conscientes del ciclo de vida significa que puede compartirlos entre múltiples actividades, fragmentos y servicios. Para mantener el ejemplo simple, puede implementar la clase LiveData como singleton

La implicación de esto es enorme: cualquier información del modelo se puede compartir en una clase singleton común dentro de un LiveDatacontenedor. Se puede inyectar de las actividades en sus respectivas ViewModelen aras de la capacidad de prueba. Y ya no necesita preocuparse por las referencias débiles para evitar pérdidas de memoria.

Usar el hashmap del enfoque de referencia débil, descrito anteriormente, y en http://developer.android.com/guide/faq/framework.html me parece problemático. ¿Cómo se reclaman las entradas completas, no solo el valor del mapa? ¿En qué ámbito lo asigna? Como el marco de trabajo controla el ciclo de vida de la Actividad, tener una de las Actividades participantes es responsable de los riesgos de tiempo de ejecución cuando el propietario es destruido antes que sus clientes. Si la aplicación lo posee, alguna actividad debe eliminar explícitamente la entrada para evitar que el hashmap retenga las entradas con una clave válida y una referencia débil recolectada potencialmente basura. Además, ¿qué debe hacer un cliente cuando el valor devuelto para una clave es nulo?

Me parece que un WeakHashMap propiedad de la Aplicación o dentro de un singleton es una mejor opción. Se accede a un valor en el mapa a través de un objeto clave, y cuando no existen referencias fuertes a la clave (es decir, todas las actividades se realizan con la clave y con qué se asigna), GC puede reclamar la entrada del mapa.

Hay varias formas de compartir datos entre actividades.

1: Pasar datos entre actividades usando Intent

Intent intent=new Intent(this, desirableActivity.class);
intent.putExtra("KEY", "Value");
startActivity(intent)

2: Usando la palabra clave estática, defina la variable como estática pública y use cualquier parte del proyecto

      public static int sInitialValue=0;

usar en cualquier parte del proyecto usando classname.variableName;

3: Uso de la base de datos

pero es un proceso un poco largo, debe usar la consulta para insertar datos e iterar datos usando el cursor cuando sea necesario. Pero no hay posibilidad de perder datos sin limpiar el caché.

4: Uso de preferencias compartidas

mucho más fácil que la base de datos. pero hay alguna limitación: no puede guardar ArrayList, List y los objetos personalizados.

5: Crear getter setter en la clase de Aplicación y acceder a cualquier parte del proyecto.

      private String data;
      public String getData() {
          return data;
      }

      public void setData(String data) {
          this.data = data;
      }

aquí configurar y obtener de las actividades

         ((YourApplicationClass)getApplicationContext()).setData("abc"); 

         String data=((YourApplicationClass)getApplicationContext()).getData();  

Bueno, tengo algunas ideas, pero no sé si son lo que estás buscando.

Puede utilizar un servicio que contenga todos los datos y luego simplemente vincular sus actividades al servicio para la recuperación de datos.

O empaquete sus datos en un serializable o parcelable y adjúntelos a un paquete y pase el paquete entre actividades.

Puede que este no sea para nada lo que estás buscando, pero también puedes intentar usar Preferencias compartidas o una preferencia en general.

De cualquier manera, hágame saber lo que decide.

Suponiendo que está llamando a la actividad dos desde la actividad uno usando un Intento.
Puede pasar los datos con intent.putExtra (),

Toma esto como referencia. Envío de matrices con Intent.putExtra

Espero que sea lo que quieras.

Si su intención es llamar a otras Actividades de la Actividad actual, debe usar Intentos . Su enfoque podría ser menos en los datos persistentes que en compartirlos según sea necesario.

Sin embargo, si realmente necesita conservar estos valores, puede conservarlos en algún tipo de archivo de texto estructurado o base de datos en el almacenamiento local. Un archivo de propiedades, un archivo XML o un archivo JSON podría almacenar sus datos y analizarse fácilmente durante la creación de la actividad. No olvide también que tiene SQLite en todos los dispositivos Android, por lo que podría almacenarlos en una tabla de base de datos. También puede usar un Mapa para almacenar pares clave-valor y serializar el mapa para el almacenamiento local, pero esto puede ser demasiado engorroso para ser útil para estructuras de datos simples.

Todas las respuestas antes mencionadas son geniales ... Solo estoy agregando una que nadie había mencionado aún sobre la persistencia de datos a través de actividades y que es utilizar la base de datos incorporada de Android SQLite para conservar datos relevantes ... De hecho, puede colocar su databaseHelper en el estado de la aplicación y llámelo según sea necesario a lo largo de las activaciones ... O simplemente haga una clase auxiliar y realice las llamadas a la base de datos cuando sea necesario ... Simplemente agregue otra capa para que considere ... Pero todas las otras respuestas serían suficientes también .. Realmente solo preferencia

Ejemplo de compartir datos entre actividades pasando un correo electrónico después de iniciar sesión

"correo electrónico" es el nombre que se puede usar para hacer referencia al valor de la actividad que se solicita

1 Código en la página de inicio de sesión

Intent openLoginActivity = new Intent(getBaseContext(), Home.class);
    openLoginActivity.putExtra("email", getEmail);

2 código en la página de inicio

Bundle extras = getIntent().getExtras();
    accountEmail = extras.getString("email");

Y si quieres trabajar con un objeto de datos, estos dos implementos son muy importantes:

Serializable vs Parcelable

• Serializable es una interfaz de marcador, lo que implica que el usuario no puede reunir los datos de acuerdo con sus requisitos. Entonces, cuando el objeto implementa Serializable Java, lo serializará automáticamente.
• Parcelable es el propio protocolo de serialización de Android. En Parcelable, los desarrolladores escriben código personalizado para organizar y desmantelar. Por lo tanto, crea menos objetos basura en comparación con la serialización
• El rendimiento de Parcelable es muy alto en comparación con Serializable debido a su implementación personalizada. Se recomienda encarecidamente utilizar la implantación de Parcelable al serializar objetos en Android.

public class User implements Parcelable

ver más en aquí