Я намагаюся працювати над тим, щоб надсилати об’єкт свого класу клієнтів з одного Activityі відображати його в іншому Activity.

Код для класу клієнтів:

public class Customer {

    private String firstName, lastName, Address;
    int Age;

    public Customer(String fname, String lname, int age, String address) {

        firstName = fname;
        lastName = lname;
        Age = age;
        Address = address;
    }

    public String printValues() {

        String data = null;

        data = "First Name :" + firstName + " Last Name :" + lastName
        + " Age : " + Age + " Address : " + Address;

        return data;
    }
}

Я хочу переслати його об'єкт від одного Activityдо іншого, а потім відобразити дані на іншому Activity.

Як я можу цього досягти?

Одним із варіантів може бути надання дозволу вашому користувальницькому класу реалізувати Serializableінтерфейс, а потім ви можете передавати екземпляри об'єктів у намірі додатково, використовуючи putExtra(Serializable..)варіант Intent#putExtra()методу.

Псевдокод :

//To pass:
intent.putExtra("MyClass", obj);

// To retrieve object in second Activity
getIntent().getSerializableExtra("MyClass");

Примітка. Переконайтесь, що кожен вкладений клас вашого основного спеціального класу має реалізований інтерфейс Serializable, щоб уникнути будь-яких винятків серіалізації. Наприклад:

class MainClass implements Serializable {

    public MainClass() {}

    public static class ChildClass implements Serializable {

        public ChildClass() {}
    }
}

Реалізуйте свій клас із Serializable. Припустимо, що це ваш клас сутності:

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

Ми відправляємо об'єкт, викликаний deneз X діяльності, до Y діяльності. Десь у X діяльності;

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

У діяльності Y ми отримуємо об'єкт.

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

Це воно.

• Використання глобальних статичних змінних не є хорошою інженерною практикою.
• Перетворення полів об’єкта в примітивні типи даних може бути неспокійним завданням .
• Використовувати серіалізацію добре, але це неефективно на платформі Android.
• Parcelable розроблений спеціально для Android, і ви повинні ним користуватися. Ось простий приклад: передача спеціальних об’єктів між Android-діями

Ви можете генерувати код парцелябельності для вашого класу за допомогою цього веб-сайту .

Використовуйте gson для перетворення вашого об'єкта в JSON та передачі його за допомогою наміру. У новій діяльності перетворіть JSON в об'єкт.

У ваших build.gradle, додайте в ваші залежності

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

У своїй діяльності перетворіть об'єкт у json-string:

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

У вашій активності отримання конвертуйте json-рядок назад у вихідний об'єкт:

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

Для Котліна це зовсім те саме

Передайте дані

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

Отримати дані

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

Під час виклику діяльності

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

У toClass.java отримуйте активність від

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

Будь ласка, переконайтеся, що клас клієнта реалізує посилки

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

На мій досвід є три основні рішення, кожне зі своїми недоліками та перевагами:

1. Реалізація Parcelable

2. Реалізація серіалізаційних

3. Використання легкої бібліотеки автобусів подій (наприклад, EventBus Greenrobot's EventBus або Otto Square)

Parcelable - швидкий і Android стандарт, але він має багато кодового шаблону і вимагає жорсткого кодування рядків для довідки, коли витягує значення з наміру (не сильно набирається).

Серіалізабельність - близька до нульової панелі котла, але це найповільніший підхід, а також вимагає жорстко закодованих рядків при витягуванні значень із наміру (не сильно вводиться).

Шина подій - нульова плита, найшвидший підхід і не вимагає жорсткого кодування рядків, але для цього потрібна додаткова залежність (хоча зазвичай легка, ~ 40 Кб)

Я розмістив дуже детальне порівняння навколо цих трьох підходів, включаючи показники ефективності.

Я знайшов простий і елегантний метод:

• НЕ Розділяється
• НЕ Серіалізується
• НЕТ статичного поля
• Немає автобусів подій

Спосіб 1

Код першої діяльності:

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

Код другого виду діяльності:

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

ви знайдете objSentі objReceivedматимете те саме hashCode, тож вони однакові.

Але чому ми можемо передавати об’єкт java таким чином?

Насправді, андроїдне в'яжуче створить глобальну посилання JNI на об'єкт java та випустить цю глобальну посилання на JNI, коли для цього об’єкта Java немає посилань. binder збереже цю глобальну посилання JNI в об'єкті Binder.

* ПОПЕРЕДЖЕННЯ: цей метод працює ТІЛЬКИ, якщо обидві дії не виконуються в одному процесі, інакше перекиньте ClassCastException за адресою (ObjectWrapperForBinder) getIntent (). GetExtras (). GetBinder ("object_value") *

Визначення класу ObjectWrapperForBinder

public class ObjectWrapperForBinder extends Binder {

    private final Object mData;

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

    public Object getData() {
        return mData;
    }
}

Спосіб 2

• для відправника,
  1. використовуйте власний нативний метод, щоб додати свій об'єкт java до глобальної довідкової таблиці JNI (через JNIEnv :: NewGlobalRef)
  2. покладіть ціле число return (власне, JNIEnv :: NewGlobalRef return taskject, який є вказівником, ми можемо передати його до int безпечно) у свій намір (через Intent :: putExtra)
• для приймача
  1. отримати ціле число від наміру (через Intent :: getInt)
  2. використовувати власний нативний метод для відновлення вашого об'єкта Java з глобальної довідкової таблиці JNI (через JNIEnv :: NewLocalRef)
  3. видалити елемент із глобальної довідкової таблиці JNI (через JNIEnv :: DeleteGlobalRef),

Але у способу 2 є невелика, але серйозна проблема, якщо приймач не зможе відновити об'єкт java (наприклад, якийсь виняток трапиться до відновлення об'єкта java, або активність приймача взагалі не існує), то об'єкт java стане сирота або витік пам’яті, метод 1 не має цієї проблеми, оскільки андроїдне в’яжуче обробляє цей виняток

Спосіб 3

Для віддаленого виклику об’єкта java ми створимо контракт / інтерфейс даних для опису об’єкта java, використовуємо файл helpl

IDataContract.aidl

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

Код першого заняття

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

Код другого виду діяльності:

змінити атрибут android: process в AndroidManifest.xml на не порожнє ім'я процесу, щоб переконатися, що друга активність виконується в іншому процесі

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

Таким чином, ми можемо передати інтерфейс між двома видами діяльності, навіть якщо вони виконуються в різних процесах, і викликати метод інтерфейсу віддалено

Метод 4

метод 3 здається недостатньо простим, тому що ми повинні реалізувати допоміжний інтерфейс. Якщо ви просто хочете виконати просту задачу і повернути значення методу непотрібно, ми можемо використовувати android.os.Messenger

Код першої діяльності (відправник):

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

Код другої діяльності (приймача):

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

    }
}

Усі Messenger.send виконуватимуться в обробнику асинхронно та послідовно.

Власне, android.os.Messenger - це також інтерфейс, що допомагає, якщо у вас є вихідний код для Android, ви можете знайти файл на ім'я IMessenger.aidl

package android.os;

import android.os.Message;

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

Ви також можете записати дані об'єкта у тимчасові рядки та ints та передати їх діяльності. Звичайно, таким чином ви отримуєте передані дані, але не сам об'єкт.

Але якщо ви просто хочете їх відобразити, а не використовувати об’єкт в іншому методі чи щось подібне, цього має бути достатньо. Я зробив це так само, щоб просто відображати дані з одного об’єкта в іншій діяльності.

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

Ви також можете передати їх безпосередньо замість тимчасових ivars, але, на мою думку, це зрозуміліше. Крім того, ви можете встановити тимчасові ivars на нуль, щоб вони швидше очистилися GarbageCollector.

Удачі!

Зі сторони: замініть написання власного способу друку замініть ToString ().

Як згадувалося в коментарях нижче, саме таким чином ви повертаєте свої дані в іншій діяльності:

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

Я зробив одноразовий клас помічників, який вміщує тимчасові предмети.

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

Замість того, щоб розміщувати ваші об'єкти в межах наміру, використовуйте IntentHelper:

IntentHelper.addObjectForKey(obj, "key");

Всередині вашої нової діяльності ви можете отримати об'єкт:

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

Майте на увазі, що після завантаження об’єкт видаляється, щоб уникнути зайвих посилань.

Є кілька способів, за допомогою яких можна отримати доступ до змінних або об'єктів в інших класах або Діяльності.

A. База даних

В. Спільні переваги.

C. Об'єктна серіалізація.

D. Клас, який може містити загальні дані, може бути названий як Загальні утиліти. Це залежить від вас.

E. Передача даних через інтеграли та інтерфейс для парцеляції.

Це залежить від потреб вашого проекту.

A. База даних

SQLite - це база даних з відкритим кодом, яка вбудована в Android. SQLite підтримує стандартні функції реляційних баз даних, такі як синтаксис SQL, транзакції та підготовлені оператори.

Підручники

В. Спільні переваги

Припустимо, ви хочете зберегти ім'я користувача. Отже, тепер буде дві речі, ключове ім'я користувача, значення значення.

Як зберігати

 // 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. Об'єктна серіалізація

Сертифікація об'єкта використовується, якщо ми хочемо зберегти стан об'єкта для надсилання його по мережі або ви також можете використовувати його за вашими цілями.

Використовуйте Java-боби і зберігайте в ньому як одне з його полів та використовуйте для цього геттери та сетер.

JavaBeans - класи Java, які мають властивості. Розгляньте властивості як приватні змінні екземпляра. Оскільки вони приватні, єдиний спосіб отримати доступ до них поза класом - це методи у класі. Методи, що змінюють значення властивості, називаються методами встановлення, а методи, які отримують значення властивості, називаються методами getter.

public class VariableStorage implements Serializable  {

    private String inString;

    public String getInString() {
        return inString;
    }

    public void setInString(String inString) {
        this.inString = inString;
    }
}

Встановіть змінну у вашому методі пошти за допомогою

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

Потім використовуйте серіалізацію об'єктів для серіалізації цього об'єкта, а в іншому класі десеріалізуйте цей об'єкт.

При серіалізації об'єкт може бути представлений у вигляді послідовності байтів, що включає дані об'єкта, а також інформацію про тип об'єкта та типи даних, що зберігаються в об'єкті.

Після того, як серіалізований об'єкт записаний у файл, його можна прочитати з файлу та дезаріалізувати. Тобто, інформація про тип і байти, які представляють об'єкт та його дані, можуть використовуватися для відтворення об'єкта в пам'яті.

Якщо ви хочете посібник для цього, зверніться до:

• Серіалізація на Java (повідомлення в блозі)

• Отримати змінну в інших класах (Переповнення стека)

D. Загальні комунальні послуги

Ви можете скласти клас самостійно, який може містити загальні дані, які вам часто потрібні у вашому проекті.

Зразок

public class CommonUtilities {

    public static String className = "CommonUtilities";

}

E. Передача даних за допомогою намірів

Будь ласка, зверніться до підручника Android - Дані про посилки для переходу між видами діяльності з використанням класів Parcelable для цього параметра передачі даних.

Створіть свій власний клас Customerнаступним чином:

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

}

У вашому 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); 
}

У xyz activityкласі вам потрібно використовувати наступний код:

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

Найкращий спосіб - мати у своєму додатку клас (називайте його Control), який міститиме статичну змінну типу "Клієнт" (у вашому випадку). Ініціалізуйте змінну у своїй діяльності А.

Наприклад:

Control.Customer = CustomerClass;

Потім перейдіть до Діяльності В і отримайте її з класу Control. Не забудьте призначити нуль після використання змінної, інакше пам’ять буде витрачена.

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

Тепер ви хочете передати об’єкт цього класу в startActivity. Просто скористайтеся цим:

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

Це працює тут, оскільки MyClass реалізує Serializable.

Якщо ви вирішили використовувати спосіб опису Саму, пам’ятайте, що можуть надсилатися лише примітивні значення. Тобто значення, які підлягають парсуванню. Отже, якщо ваш об'єкт містить складні об'єкти, це не буде слідувати. Наприклад, такі змінні, як Bitmap, HashMap тощо ... Це важко пройти через наміри.

Загалом , я б порадив вам послати тільки примітивні типи даних в якості статистів, як String, Int, логічне і т.д. У вашому випадку це буде: String fname, String lname, int age, і String address.

Моя думка: Складніші об’єкти краще поділяти, впровадивши ContentProvider , SDCard тощо. Також можливо використовувати статичну змінну , але це може швидко призвести до схильного до помилок коду ...

Але знову ж таки, це лише моя суб’єктивна думка.

Я використовую посилки для передачі даних від однієї діяльності до іншої активності. Ось мій код, який чудово працює в моєму проекті.

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

У діяльностіА використовуйте його так:

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

У ActivityB використовуйте його так, щоб отримати дані:

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

Ви можете спробувати використовувати цей клас. Обмеження полягає в тому, що його не можна використовувати поза одним процесом.

Один вид діяльності:

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

Інша діяльність:

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

Почніть іншу діяльність з цієї діяльності та передайте параметри через Об'єкт зв’язку

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

Отримати дані про іншу діяльність (YourActivity)

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

Це нормально для простого типу даних. Але якщо ви хочете передати складні дані між видами діяльності. Вам потрібно спершу її серіалізувати.

Тут ми маємо модель працівника

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

    getters...
    setters...
}

Ви можете використовувати Gson lib, наданий google, для серіалізації таких складних даних

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

Це питання також обговорюється в іншому запитанні про переповнення стека. Будь ласка, подивіться на рішення для передачі даних за допомогою намірів із використанням Serializable . Основний момент полягає у використанні Bundleоб'єкта, який зберігає необхідні дані всередині Intent.

 Bundle bundle = new Bundle();

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

 intent.putExtras(bundle);

Для отримання значень:

 Bundle bundle = new Bundle();

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

Перевагою Serializableє її простота. Однак вам слід розглянути можливість використання Parcelableметоду, якщо вам потрібно перенести багато даних, оскільки Parcelableвін спеціально розроблений для Android і є більш ефективним, ніж Serializable. Ви можете створити Parcelableклас за допомогою:

1. інтернет-інструмент - посилкувач
2. плагін для Android Studio - генератор коду для парцеляції Android

Крійте такий клас, як клас квасолі та реалізуйте Serializableінтерфейс. Тоді ми можемо передати його intentметодом, наприклад:

intent.putExtra("class", BeanClass);

Потім отримайте це з іншого виду діяльності, наприклад:

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

Створіть два способи у вашому користувальницькому класі, як це

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

Тепер у вашій діяльності відправника зробіть це так

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

І у вашій активності приймача

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

Так, використання статичного об'єкта - це найпростіший спосіб зробити це за допомогою користувацьких несерійних об'єктів.

Об'єкти діяльності Android можна знищити та відновити. Отже, вам потрібно буде використовувати інший підхід, щоб їх подивитися - або будь-який об’єкт, який вони створюють !!! - вгору. Тобто, ви можете передати як статичну посилання на клас, але тоді обробка об’єкта (Java називає ці "посилання", як це робить SmallTalk; але вони не є посиланнями в сенсі С або збірки) згодом, можливо, буде недійсною, оскільки "функція" Android OE - будь-яка діяльність може бути знищена та відновлена ​​пізніше.

В оригінальному запитанні було задано "Як передати об'єкт з однієї діяльності на іншу в Android", і ніхто на це не відповів. Напевно, ви можете серіалізувати (Serializable, Parcelable, до / від JSON) і передавати копію даних об’єкта, і новий об’єкт, що має ті самі дані, може бути створений; але він НЕ матиме однакових посилань / ручок. Також багато хто згадав, що ви можете зберігати посилання в статичному магазині. І це буде працювати, якщо Android не вирішить знищити вашу активність.

Отже, щоб реально вирішити оригінальне питання, вам знадобиться статичний пошук плюс кожен об'єкт оновить свою посилання, коли / якщо він буде відтворений. Наприклад, кожна Android-операція буде переспівуватися, якщо викликається її onCreate. Ви також можете побачити, як деякі люди використовують список завдань для пошуку діяльності за іменем. (система тимчасово знищує цей екземпляр діяльності, щоб заощадити простір.

Довідково:

Зупинено: "Діяльність повністю затьмарена іншою діяльністю (активність зараз знаходиться у" фоновому режимі "). Припинена активність також залишається активною ( об'єкт" Активність "зберігається в пам'яті ; він зберігає всю інформацію про стан та інформацію про учасників, але не є додається до менеджера вікон). Однак він більше не видно користувачеві, і система може його знищити, коли пам'ять потрібна в іншому місці ".

onDestroy "система тимчасово знищує цей екземпляр діяльності для економії місця".

Отже, Шина повідомлень - це ефективне рішення. Це в основному "каламбури". Замість того, щоб намагатися мати посилання на об'єкти; то ви реконструюєте свій дизайн, щоб використовувати MessagePassing замість SequentialCode. Експоненціально важче налагоджувати; але це дозволяє ігнорувати подібне розуміння OperatingEl Environment. Ефективно, доступ до кожного методу об'єкта інвертується, тому абонент розміщує повідомлення, а сам об'єкт визначає обробник цього повідомлення. Багато іншого коду, але може зробити його надійним із обмеженнями для Android OE.

Якщо все, що ви хочете, - це найпопулярніша активність (типова річ в додатках для Android через те, що "Контекст" потрібен повсюдно), то ви можете просто мати кожен список списку активностей як "верхній" у статичному глобальному просторі, коли він буде викликаний. Тоді ваш AlertDialog або все, що потребує контексту, може просто захопити його звідти. Крім того, це трохи вдало використовувати глобальний, але може спростити проходження контексту вгору і вниз скрізь, і, звичайно, коли ви використовуєте MessageBus, то це все-таки глобально.

1. Я знаю, що статика погана, але здається, що ми змушені її тут використовувати. Проблема з parceables / seriazables полягає в тому, що обидві дії мають повторювані екземпляри одного і того ж об'єкта = витрата пам'яті та процесора.

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

Активність виклику

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

Викликана активність (зауважте, що onCreate () та onResume () можна викликати кілька разів, коли система знищує та відтворює дії)

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

2. Інший спосіб - оголосити статичне поле класу, яке ви хочете передати саме в цьому класі. Він буде служити лише для цієї мети. Не забувайте, що він може бути нульовим в onCreate, оскільки ваш додаток було вивантажено з пам'яті системою та перезавантажено пізніше.

3. Маючи на увазі, що вам все-таки потрібно обробляти життєвий цикл діяльності, можливо, ви захочете записати всі дані прямо до загальних налаштувань, болісно складних структур даних, як це є.

Наведені вище відповіді майже всі правильні, але для тих, хто не скасовує ці відповіді, Android має потужний клас Намір, за допомогою якого ви обмінюєтесь даними між не лише діяльністю, але й іншими компонентами Android (приймач мовника, сервіси для контенту передбачають, що ми використовуємо клас ContetnResolver без наміру ). У своїй діяльності ви формуєте наміри

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

У вашій приймальній діяльності у вас є

public class SomeActivity extends AppCompactActivity {

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

}

Ви повинні реалізувати інтерфейс Parceable або Serializable на своєму об'єкті, щоб ділитися між видами діяльності. Важко реалізувати Parcealbe, а не Serializable інтерфейс на об'єкті, тому Android має плагін спеціально для цього. Завантажте його та використовуйте його

Мені завжди було цікаво, чому це не може бути таким простим, як використання іншого методу. Нещодавно я написав бібліотеку утиліт, яка робить її майже такою ж простою. Ви можете перевірити це тут ( https://github.com/noxiouswinter/gnlib_android/wiki/gnlauncher ).

GNLauncher дозволяє надсилати об’єкти / дані до діяльності з іншої діяльності тощо так само просто, як викликати функцію в тій діяльності з необхідними даними як параметри. Він запроваджує безпеку типу та видаляє всі стихії, що потребують серіалізації, приєднуючись до наміру за допомогою рядкових клавіш та скасовуючи їх на іншому кінці.

Використання

Визначте інтерфейс із методами, які потрібно закликати до запуску Діяльності.

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

Вкажіть вищевказаний інтерфейс на Активність, яку потрібно запустити. Також повідомте GNLauncher, коли діяльність буде готова.

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

В іншому «Активність» знайдіть проксі-сервер до вищезазначеної діяльності та зателефонуйте до будь-якого методу із потрібними параметрами.

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

Перша активність буде запущена, і метод буде запроваджено з необхідними параметрами.

Передумови

Зверніться до https://github.com/noxiouswinter/gnlib_android/wiki#prerequisites, щоб отримати інформацію про те, як додати залежності.

Передайте об'єкт від однієї діяльності до іншої діяльності.

(1) джерельна діяльність

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

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

(2) активність призначення

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

Раніше я встановлював об'єкт за допомогою Pacelable або Serializable для передачі, але щоразу, коли я додаю інші змінні в об'єкт (модель), я мушу це все реєструвати. Це так незручно.

Передавати об’єкт між видами діяльності або фрагментами дуже просто

Android DataCache

Ми можемо передати об’єкт від однієї діяльності до іншої діяльності:

SupplierDetails poSuppliersDetails = new SupplierDetails();

Всередині у poSuppliersDetailsнас є деякі значення. Тепер я надсилаю цей об’єкт для цільової діяльності:

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

Як отримати це в ACtivityTwo:

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

Передайте одну активність іншій:

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

Отримати значення:

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

Привіт всім Я бачу багато хороших варіантів, але мені було цікаво, чому Binding не використовується?

Передача посилання на об'єкт мені здається більш ефективною, ніж серіалізація та дестерилізація об'єктів, але я не здійснив глибокого занурення, щоб переконатися, що це відбувається за лаштунками.

Створити палітурку досить просто ...

public class MyBinder extends Binder {

    private Object myObject;

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

    public Object getObject() {
        return myObject;
    }

}

І створення проділу для його використання не так вже й поганий ефір.

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

    };
}

Ця логіка дійсно класна, тому що ви фактично передаєте посилання від діяльності до діяльності.

Я б радив перевірити наявність нулів, і якщо instanceof Binder є MyBinder!

і реалізувати це ви просто ...

Відправте це

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

intent.putExtra("MyParcelable", myParcelable);

Поверніть його

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

Чорт забирає, що хтось може зійти з розуму і зробити цю присоску справжньою родовою.