Androidで1つのアクティビティから別のアクティビティにオブジェクトを渡す方法


779

ある顧客クラスのオブジェクトを送信して別のオブジェクトに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

どうすればそれを達成できますか?


1
おそらくあなたは、大衆の意見を考慮して、受け入れられた答えを変更すべきです。
Rohit Vipin Mathews

以前はオブジェクトをPacelableまたはSerializableに設定していましたが、他の変数を追加するときは常に、PacelableまたはSerializableを取得および設定する関数にすべて追加する必要があります。そこで、DataCacheを作成して、アクティビティとフラグメントの間を転送しました。github.com/kimkevin/AndroidDataCacheオブジェクトの転送は非常に簡単です。
kimkevin、2015年

回答:


886

1つのオプションとして、カスタムクラスに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() {}
    }
}

126
@OD:私の弁護では、これが最良の選択肢であると言ったことはありません。OPが代替案を要求したところ、私が提案しました。とにかく、ありがとう。
Samuh、

83
なぜSerializableは良いオプションではないのですか?これはよく知られたインターフェースであり、人々のクラスがすでに実装している可能性が十分にあります(たとえば、ArrayListはすでにSerializableです)。あるクラスから別のクラスにデータを単に渡すために、データオブジェクトを変更してコードを追加する必要があるのはなぜですか?それは悪いデザインのようです。ある程度のパフォーマンスの影響があると想像できますが、99%の場合、人々は少量のデータを渡していて、気にしないと思います。シンプルでポータブルな方が良い場合もあります。
ネイト

16
@サンダー:この答え(stackoverflow.com/questions/2139134/…)は間違っていますか?彼は言うParcelable IS特にその目的のために設計された(とはるかに速くよりもSerializable)。私は混乱しています。
Slauma、2011年

41
Parcelable速度は良いかもしれませんが、実装は複雑です。アクティビティ間で渡す必要のある8つのオブジェクトがある場合、それぞれを作成しますかParcelableSerializable代わりに使用する方が理にかなっています。実装Parcelableするときは、クラスに多くのコードを追加し、非常に特殊な方法でフィールドを並べ替える必要があります。Serializableあなたはしません。結局のところ、渡すオブジェクトの数と、何をしようとしているのかが問題だと思います。
BlackHatSamurai 2012

15
Serializable標準のJavaインターフェースです。インターフェイスを提供することにより、クラスをSerializableにマークするだけで、Javaは特定の状況で自動的にそれをシリアル化します。 Parcelableシリアライゼーションを自分で実装するAndroid固有のインターフェースです。これは、Serializableよりもはるかに効率的で、デフォルトのJavaシリアライゼーションスキームに関するいくつかの問題を回避するために作成されました
Gaurav Arora

311

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

deneXアクティビティから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");

それでおしまい。


1
それは私にとって本当に役に立ちました。ありがとう...しかし、渡されたオブジェクトを受け取るとき、構文は次のようになります[Deneme dene =(Deneme)i.getSerializableExtra( "sampleObject"); ] ... それは...ですか ???
JibW

1
@MustafaGüvenしかし、私はそうすることで得classCastException: java.lang.Longています。理由を教えてください。
Shajeel Afzal 2013

私の答えとは何の関係もありません。それはあなたが得ているものとは非常に異なります。コードを共有していただけませんか?
MustafaGüven2013年

1
シリアライズ可能は、大きなPOJOには遅すぎます。バスの使用は、はるかに優れたパターンです。
スティーブンマークフォード

1
(Serializable)オブジェクトにプレフィックスを付ける必要があるのはなぜですか?
Alston、2014

123
  • グローバル静的変数を使用することは、ソフトウェアエンジニアリングの習慣としては適切ではありません
  • オブジェクトのフィールドをプリミティブデータ型に変換することは、大変な作業になる可能性があります。
  • シリアライズ可能の使用は問題ありませんが、Androidプラットフォームではパフォーマンス効率が良くありません
  • Parcelableは特に Android用に設計されており、使用する必要があります。以下に簡単な例を示します。Androidアクティビティ間でカスタムオブジェクトを渡す

このサイトを使用して、クラスのParcelableコードを生成できます


4
オブジェクトにネストされたArraylistが含まれている場合はどうなりますか?
aNdRO博士2014年

10
まあ多分しかし、人は本当に塩イモの粒で「パフォーマンス」を取るべきです。それが実装の代償となるならParcelable、私はむしろPOJOクラスをAndroidにとらわれずに使い、を使用したいと思いますSerializable
VH-NZZ

Parcelableを使用することに同意しません。単純なBUSパターンは実行時にはるかに効率的であり、多くの開発時間を節約します。
スティーブンマークフォード

15
このベンチマークによると、bitbucket.org / afrishman / androidserializationtest SerializableはParcelableよりもはるかに高速です。Parcelableについてのこの5歳のナンセンスの共有を停止してください。
アフリカの2015年

7
グローバル静的変数はどのように「ソフトウェアエンジニアリングの実践として不適切」ですか。シングルトンキャッシュやデータグリッドなどを作成し、IDなどを渡すことができます。Javaで参照を渡す場合は、同じオブジェクトを指すため、ある意味でグローバル静的変数を使用しています。
ブレークライン2016

112

使用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-stringを元のオブジェクトに変換します。

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

Kotlinそれは全く同じです

データを渡す

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)

3
そのやり過ぎであるgsonは、単なるjsonへの文字列シリアル化の一種であり、SerializableまたはParacableを実装するのに適しています。
James Roeiter、2013

14
それを処理するライブラリー(gson)を使用できる場合は、すべてのオブジェクトとすべてのプロジェクト(時間の無駄)でシリアライズ可能を実装する必要はありません。そして、やり過ぎについては、そこにデュアルとクアッドコアの電話があり、この回答のアイデアに従うリストでも処理できます。
sagits 2015年

4
gsonは上記に加えてarraylistもシリアル化できるため、gsonの使用もお勧めします。
nurgasemetey 2015

4
これは素晴らしい!私の場合、オブジェクトがシリアライズ可能またはパーセル可能を実装しないライブラリを使用しています。これが私の唯一のオプションは、私の知る限りである
チャド・ビンガム

2
これが「最良の」オプションです。一部のクラスは非常に単純なので、シリアライズ可能を実装することで実装を過度に複雑にする必要はありません
Ojonugwa Jude Ochalifu

98

アクティビティを呼び出している間

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

アダヴァン、私は質問を受けました。最初のIntentクラスを作成するときは、最初の引数としてfromClass.thisを渡します。受信アクティビティクラスでこのオブジェクトを取得する方法はありますか?
ニューマン

1
Miliu、fromClass fr =(fromClass)getParent(); これはあなたが必要なものですか?
2009

Adhava、私は実際にこれをしましたが、frはnullです。なぜか?
ニューマン'09 / 09/25

miliu、例外トレースを調査できますので、共有してください。
広告

Parcelableは、不必要なボイラープレートコードがたくさんあり、率直に言って、時間の無駄です。むしろバスを使用してください。以下の私の投稿を参照してください。
スティーブンマークフォード

89

私の経験では、主に3つの解決策があり、それぞれに欠点と利点があります。

  1. Parcelableの実装

  2. Serializableの実装

  3. ある種の軽量のイベントバスライブラリ(たとえば、GreenrobotのEventBusやSquareのOtto)を使用する

Parcelable-高速かつAndroid標準ですが、定型コードが多く、値をインテント(厳密に型指定されていない)から取り出すときに参照用にハードコードされた文字列が必要です。

シリアライズ可能 -ボイラープレートはゼロに近いですが、これは最も遅いアプローチであり、値をインテントから取り出すときに(強く型付けされていない)ハードコードされた文字列も必要です。

イベントバス -ボイラープレートがゼロで最速のアプローチであり、ハードコードされた文字列は必要ありませんが、追加の依存関係が必要です(通常は軽量ですが、最大で40 KB)。

効率のベンチマークを含め、これら3つのアプローチに関する非常に詳細な比較を投稿しました。


4
記事へのリンクは死んでいます。
引き続き

リンクがダウンしているのは残念です:(
Mauker

イベントバスの使用に関する問題は、たとえばローテーションによってターゲットアクティビティが再作成される場合です。この場合、渡されたオブジェクトは以前の呼び出しによってバスから消費されたため、ターゲットActivityは渡されたオブジェクトにアクセスできません。
JuliuszJ 2018

1
Parcelableが最速で、このジェネレーター(parcelabler.com)を使用すると、クラスを貼り付けることができ、コードを生成できます。シンプル。
ByWaleed

1
@ByWaleed ...私は絶対に同意します。私は常にこのサイトを使用しており、手間をかけずにコンテンツを作成しています。ただし、別のオブジェクトで構成されるPOJOを使用しようとすると、何度も失敗しました。何らかの理由でその出力は実際には機能しません。
ヨアプリ

42

私はシンプルでエレガントな方法を見つけました:

  • 小包不可
  • シリアライズ不可
  • 静的フィールドなし
  • イベントバスなし

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

2番目のアクティビティのコード:

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

あなたは見つけるでしょうobjSentobjReceived同じを持っていますhashCodeするので、彼らは同じです。

しかし、なぜこの方法でJavaオブジェクトを渡すことができるのでしょうか。

実際、Androidバインダーは、JavaオブジェクトのグローバルJNI参照を作成し、このJavaオブジェクトの参照がない場合、このグローバルJNI参照を解放します。バインダーは、このグローバルJNI参照をバインダーオブジェクトに保存します。

*注意:このメソッドは、2つのアクティビティが同じプロセスで実行されない限り機能します。それ以外の場合は、(ObjectWrapperForBinder)getIntent()。getExtras()。getBinder( "object_value")*でClassCastExceptionをスローします。

クラスObjectWrapperForBinder defination

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. 戻り整数(実際には、JNIEnv :: NewGlobalRef return jobject、これはポインターです。これをintに安全にキャストできます)をIntent :: putExtraを介して
  • 受信機用
    1. Intentから整数を取得する(Intent :: getIntを使用)
    2. カスタムネイティブメソッドを使用して、JNIグローバル参照テーブルからJNIEnv :: NewLocalRefを介してJavaオブジェクトを復元します
    3. JNIグローバル参照テーブルからアイテムを削除します(JNIEnv :: DeleteGlobalRefを使用)。

ただし、方法2には少し深刻な問題があります。レシーバーがJavaオブジェクトの復元に失敗した場合(たとえば、Javaオブジェクトを復元する前に何らかの例外が発生した場合、またはレシーバーアクティビティがまったく存在しない場合)、Javaオブジェクトは孤立またはメモリリーク、方法1にはこの問題はありません。Androidバインダーがこの例外を処理するためです。

方法3

Javaオブジェクトをリモートで呼び出すために、Javaオブジェクトを記述するデータコントラクト/インターフェースを作成し、aidlファイルを使用します

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

2番目のアクティビティのコード:

AndroidManifest.xmlのandroid:process属性を空でないプロセス名に変更して、2番目のアクティビティが別のプロセスで実行されるようにします

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

このようにして、2つのアクティビティが異なるプロセスで実行されている場合でも、それらの間でインターフェースを渡し、インターフェースメソッドをリモートで呼び出すことができます。

方法4

方法3は、aidlインターフェイスを実装する必要があるため、単純ではないようです。単純なタスクを実行するだけで、メソッドの戻り値が不要な場合は、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)));
    }
}

2番目のアクティビティ(レシーバー)のコード:

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

申し訳ありませんが、あなたの回答に拘束力があることはわかりませんでした。また、あなたの回答も非常にエレガントだと思います。
SkidRunner

うわー..この男の最初の方法は途方もないです.....非常に大きい/大きいサイズのオブジェクトがうまく機能する場合
karan

私はメソッド1を使用しているので、時間を節約できます。ありがとう。
ShweLiam

ObjectWrapperForBinderメソッドに感謝します。本当に役に立ちます。
ウラジミールトルスティコフ

40

オブジェクトのデータを一時的な文字列と整数に書き込み、それらをアクティビティに渡すこともできます。もちろん、その方法では、データは転送されますが、オブジェクト自体は転送されません。

しかし、それらを表示したいだけで、オブジェクトを別のメソッドなどで使用しない場合は、それで十分です。あるオブジェクトのデータを別のアクティビティで表示するのと同じ方法で行いました。

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

temp ivarの代わりに直接渡すこともできますが、このようにすると、私の意見ではより明確になります。さらに、temp ivarをnullに設定して、GarbageCollectorによってより早くクリーンアップされるようにすることができます。

幸運を!

余談ですが、独自の印刷メソッドを作成する代わりにtoString()をオーバーライドしてください。

以下のコメントで述べたように、これは別のアクティビティでデータを取得する方法です。

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

9
次のようにして、データを再度取得します。String fName = getIntent()。getExtras()。getInt( "fname");
アリスター

2
データを取り戻すには:Bundle extras = getIntent().getExtras(); String val = extras.getString("fname");
Eric Leschinski、2012年

1
これは、大きなPOJOではすぐに実行不可能になる可能性があります。むしろバスを使用してください。以下の私の投稿を参照してください。
スティーブンマークフォード

私の回答で述べたように、これは、オブジェクト自体ではなく、いくつかの値だけが必要な単純なユースケース用です。複雑なユースケースの解決策となることはできません。
MJB 2014

1
単一のオブジェクトを渡すのは良い考えですが、オブジェクトのサイズが不明な配列を渡そうとしています。おそらく、ソリューションはオブジェクト配列を渡すためのものではありません。
ムハンマドサキブ2015

25

一時オブジェクトを保持するシングルトンヘルパークラスを作成しました。

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

オブジェクトをIntent内に配置する代わりに、IntentHelperを使用します。

IntentHelper.addObjectForKey(obj, "key");

新しいアクティビティ内で、オブジェクトを取得できます。

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

読み込まれると、不要な参照を避けるためにオブジェクトが削除されることに注意してください。


1
良いアイデア!さらに、追加のクラスObjectContainer {Object、obj;を作成できる場合もあります。ブール永久; ....}アイデアは、オブジェクトを永続化する必要があり、getを呼び出すときに削除しない場合は、addメソッドでブール値を渡すことです。一部のグローバルオブジェクトを保持するのに役立ちます。オープンBluetooth接続などの可能性があります
Umair 2012

1
かわいいが、ホイールを再発明しないでください。バスパターンはエレガントでより強力です。以下の私の投稿を参照してください。
スティーブンマークフォード

@StevenMarkFordでは、バスパターンは今日までまだ当てはまりますか?私は活動の間に、このデータにアクセスするようなコードとコードベースを改善しようとしています:BookActivity.getInstance().recommendationResponseRoomsActivity
Woppi

受信アクティビティが再作成されると(画面の回転などで)にobjなりnullます。これを回避するには、objどこかに保存して再度取得する必要があります。実際、JsonソリューションはオブジェクトデータをIntentに格納します。
サルバドール

25

他のクラスやアクティビティの変数やオブジェクトにアクセスする方法はいくつかあります。

A.データベース

B.共有設定。

C.オブジェクトのシリアル化。

D.共通データを保持できるクラスは、Common Utilitiesと名付けることができます。あなた次第です。

E. IntentsおよびParcelable Interfaceを介してデータを渡す。

プロジェクトのニーズによって異なります。

A. データベース

SQLiteは、Androidに組み込まれているオープンソースデータベースです。SQLiteは、SQL構文、トランザクション、準備されたステートメントなどの標準のリレーショナルデータベース機能をサポートしています。

チュートリアル

B. 共有設定

ユーザー名を保存したいとします。したがって、キーのユーザー名と値の値の2つが存在することになります。

収納方法

 // 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 Beanを使用して、フィールドの1つとしてJava Beanに格納し、そのためにゲッターとセッターを使用します。

JavaBeansは、プロパティを持つJavaクラスです。プロパティはプライベートインスタンス変数と考えてください。それらはプライベートなので、クラスの外部からアクセスできる唯一の方法は、クラスのメソッドを使用することです。プロパティの値を変更するメソッドはセッターメソッドと呼ばれ、プロパティの値を取得するメソッドはゲッターメソッドと呼ばれます。

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

次に、オブジェクトのシリアル化を使用してこのオブジェクトをシリアル化し、他のクラスでこのオブジェクトを逆シリアル化します。

シリアル化では、オブジェクトは、オブジェクトのデータ、およびオブジェクトのタイプとオブジェクトに格納されているデータのタイプに関する情報を含むバイトのシーケンスとして表すことができます。

シリアル化されたオブジェクトがファイルに書き込まれた後、ファイルから読み取って逆シリアル化できます。つまり、オブジェクトとそのデータを表す型情報とバイトを使用して、メモリ内にオブジェクトを再作成できます。

このチュートリアルが必要な場合は、以下を参照してください。

D. CommonUtilities

プロジェクトで頻繁に必要となる一般的なデータを含むクラスを自分で作成できます。

サンプル

public class CommonUtilities {

    public static String className = "CommonUtilities";

}

E. インテントを介してデータを渡す

データを渡すこのオプションについては、Parcelableクラス使用してアクティビティ間で渡すチュートリアルAndroid-Parcel dataを参照してください。


22

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

..「バンドル」を渡すコードをput cust objのキーとして確認し、「クラス」から取得する..plsは「クラス」または「バンドル」のいずれか1つのキーを使用する..
AK Joshi

エラーが発生しました:Parcelableでシリアル化可能なオブジェクトの書き込み中にIOExceptionが発生しました
Arul Mani

15

最良の方法は、アプリケーションに「Customer」タイプの静的変数(この場合)を保持するクラス(Controlと呼ぶ)を用意することです。アクティビティAの変数を初期化します。

例えば:

Control.Customer = CustomerClass;

次に、アクティビティBに移動し、Controlクラスからフェッチします。変数を使用した後でnullを割り当てることを忘れないでください。そうしないと、メモリが浪費されます。


4
@aezこれは、設計の観点からみてずさんであり、Intentが別のプロセスにある場合はひどく壊れるからです。

7
アプリをアクティビティBに再開すると、問題が発生します。アクティビティはAndroidによって強制終了される可能性があるため、オブジェクトは保存されません。
Ryan R

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

次に、このクラスのオブジェクトをstartActivityに渡します。単にこれを使用してください:

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

MyClassがを実装しているため、ここで機能しますSerializable


さらに説明または詳しく説明してください
Amitsharma '30

HomeworkData homeworkData = homeWorksList.get(position); Intent intent = new Intent(c、HomeWorkActivitydetail.class); バンドルb =新しいBundle(); b.putSerializable( "CompleteData"、homeworkData); intent.putExtras(b); c.startActivity(intent); オブジェクトの追加時に、オブジェクト要素を追加するときにいくつかのエラーが発生します。これで完全なオブジェクトを渡すことができません
Amitsharma

homeworkDataの内部で、これらの値が追加されるようになりました
Amitsharma

12

Samuhが説明する方法を使用する場合は、プリミティブ値しか送信できないことに注意してください。つまり、parcableな値です。したがって、オブジェクトに複雑なオブジェクトが含まれている場合、これらは従いません。たとえば、ビットマップ、ハッシュマップなどの変数...これらはインテントで渡すのが難しいです。

一般的に、私はあなたの場合、それは次のようになり内の文字列、int型、ブールなどのように、エキストラとしてのみプリミティブデータ型を送信するためにあなたをアドバイスします:String fnameString lnameint age、とString address

私の意見:ContentProviderSDCardなどを実装することで、より複雑なオブジェクトをよりよく共有できます。静的変数を使用することも可能です。やすくなります。が、これによりエラーが発生しやすいコードにつながる可能性があります...

しかし、繰り返しますが、それは私の主観的な意見です。


8

Parcelableを使用して、あるアクティビティから別のアクティビティにデータを送信しています。これが私のプロジェクトでうまく機能する私のコードです。

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

activityAでは、次のように使用します。

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

7

そのクラスを使用してみることができます。制限は、1つのプロセスの外では使用できないことです。

1つのアクティビティ:

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

6

このアクティビティから別のアクティビティを開始し、バンドルオブジェクトを介してパラメーターを渡します

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

Googleが提供するGson libを使用して、このような複雑なデータをシリアル化できます

String strEmp = new Gson().toJson(emp);
Intent intent = new Intent(getBaseContext(), YourActivity.class);
intent.putExtra("EMP", strEmp);
startActivity(intent);

Bundle bundle = getIntent().getExtras();
String empStr = bundle.getString("EMP");
            Gson gson = new Gson();
            Type type = new TypeToken<Employee>() {
            }.getType();
            Employee selectedEmp = gson.fromJson(empStr, type);

TypeToken <>は非推奨です。代わりは何ですか?
ラガベンドラM

6

この質問は、別のスタックオーバーフローの質問でも説明されています。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は、その単純さです。ただし、はAndroid用に特別に設計されており、より効率的Parcelableであるため、多くのデータを転送する必要がある場合は、メソッドの使用を検討する必要があります。以下を使用してクラスを作成できます。ParcelableSerializableParcelable

  1. オンラインツール-parcelabler
  2. Android Studioのプラグイン-Android Parcelableコードジェネレーター

5

Beanクラスのようなクラスを作成し、Serializableインターフェースを実装します。次に、それをintentメソッドに渡すことができます。次に例を示します。

intent.putExtra("class", BeanClass);

次に、他のアクティビティから取得します。次に例を示します。

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

5

このようにカスタムクラスに2つのメソッドを作成します

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

3

ええ、静的オブジェクトを使用することは、カスタムの非直列化オブジェクトでこれを行う最も簡単な方法です。


ええ、私は実際にあなたに同意すると思います。これらのオブジェクトを作成することstaticは、putExtra()渡したいすべてのプロパティに対して呼び出しを続けるのが単に非実用的である場合、より良い回避策です。たとえば、現在、ArrayListオブジェクトを含むを渡したいと考えています。static代わりにArrayList を作成することもできます。
マシュー・キロス2011

3

Androidアクティビティオブジェクトは破棄して再構成できます。したがって、それらを見るには別のアプローチを使用する必要があります-または、それらが作成するオブジェクト !!! -アップ。つまり、静的クラス参照として渡すことはできますが、オブジェクトハンドル(SmallTalkのようにJavaがこれらの「参照」を呼び出しますが、Cまたはアセンブリの意味での参照ではありません)は、「機能」が原因で後で無効になる可能性があります。 Android OEのすべてのアクティビティは、後で消滅して再構成できます。

元の質問では、「Androidでオブジェクトをあるアクティビティから別のアクティビティに渡す方法」が尋ねられましたが、誰も答えていません。確かに、シリアル化(Serializable、Parcelable、JSON間)してオブジェクトのデータのコピーを渡すことができ、同じデータを持つ新しいオブジェクトを作成できます。ただし、同じ参照/ハンドルはありません。また、他の多くの人が静的ストアに参照を保存できると述べました。そして、AndroidがあなたのアクティビティをonDestroyすることを決定しない限り、それは機能します。

したがって、元の質問を実際に解決するには、静的ルックアップが必要であり、各オブジェクトは、再作成時に参照を更新します。たとえば、onCreateが呼び出されると、各Androidアクティビティは自身を再リストします。一部の人がタスクリストを使用して名前でアクティビティを検索する方法も確認できます。(スペースを節約するために、システムはこのアクティビティのインスタンスを一時的に破棄しています。.getRunningTasks、タスクリストは事実上、各アクティビティの最新のオブジェクトインスタンスの特別なリストです)。

参考のために:

停止:「アクティビティは別のアクティビティによって完全に隠されます(アクティビティは現在「バックグラウンド」にあります)。停止したアクティビティもまだ存続しています(アクティビティオブジェクトはメモリ保持され、すべての状態とメンバー情報を保持しますが、ウィンドウマネージャーに接続されています。ただし、ユーザーには表示されなくなり、メモリが他の場所で必要になったときにシステムによって強制終了される可能性があります。」

onDestroy " スペースを節約するために、システムはアクティビティのこのインスタンスを一時的に破棄しています。"

したがって、メッセージバスは実行可能なソリューションです。基本的には「パント」です。オブジェクトを参照しようとするのではなく、次に、SequentialCodeではなくMessagePassingを使用するように設計を再構築します。デバッグが指数関数的に難しくなります。ただし、このようなOperatingEnvironmentの理解を無視できます。実際には、各オブジェクトメソッドアクセスが逆になっているため、呼び出し元はメッセージを投稿し、オブジェクト自体がそのメッセージのハンドラーを定義します。より多くのコードが含まれますが、Android OEの制限により堅牢にすることができます。

必要なのがトップアクティビティのみである場合(どこでも「コンテキスト」が必要になるため、Androidアプリでは一般的なことです)、onResumeが呼び出されるたびに、静的グローバルスペースで各アクティビティにそれ自体を「トップ」としてリストさせることができます。次に、AlertDialogまたはコンテキストを必要とするものは何でもそこから取得できます。また、グローバルを使用するのは少し面倒ですが、コンテキストをどこにでも上下に渡すことを簡略化できます。確かに、メッセージバスを使用する場合、ITはとにかくグローバルです。


Ottoには、プレーンな古いJavaアプリで外部から実行できるという長所があります。したがって、Androidをいじる必要がない開発とテストに適しています。Ottoには大きな学習曲線のconがあり、それが解決するもののほとんどはすでにAndroidの方法(ローカルブロードキャストなど)または通常のアプリ開発アプローチで解決されています(Ottoのグローバルルックアップよりもはるかに単純なグローバルルックアップを記述できますが、通常のアプローチは多くの場合コードを介したベクトル化/ F3およびデバッグの段階的実行に、より近づきやすくなります)。
TimJowers2 2014

2
  1. staticが悪いことは知っていますが、ここではそれを使用せざるを得ないようです。parceables / seriazablesの問題は、2つのアクティビティに同じオブジェクトの重複インスタンスがあることです。つまり、メモリとCPUの浪費です。

    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()
  1. もう1つの方法は、そのクラスに渡すクラスの静的フィールドを宣言することです。それはこの目的のためだけに役立ちます。アプリパッケージがシステムによってメモリからアンロードされ、後でリロードされているため、onCreateではnullになる可能性があることを忘れないでください。

  2. アクティビティのライフサイクルを処理する必要があることを念頭に置いて、すべてのデータを共有設定に直接書き込み、複雑なデータ構造をそのまま使用するのは面倒です。


1

上記の答えはほぼすべて正解ですが、それらの答えを理解できない人のために、Androidには強力なクラスIntentがあり、それだけでなく、アクティビティのデータだけでなく、Androidの別のコンポーネント(ブロードキャストレシーバー、コンテンツのサービス)の間でもデータを共有できます。 )。あなたの活動の中で意図を築く

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インターフェースを実装する必要があります。オブジェクトにSerializableインターフェースで はなくParcealbeを実装するのは難しいため、Androidには特にプラグインがあります。ダウンロードして使用してください。


0

なぜこれが他のアクティビティのメソッドを呼び出すほど簡単にできないのかといつも思っていました。私は最近、それと同じくらい簡単にするユーティリティライブラリを作成しました。こちらでチェックできます(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を参照してください


0

オブジェクトをあるアクティビティから別のアクティビティに渡します。

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

0

以前は転送にPacelableまたはSerializableを使用してオブジェクトを設定していましたが、object(model)に他の変数を追加するたびに、すべてを登録する必要があります。それはとても不便です。

アクティビティやフラグメント間でオブジェクトを転送するのは非常に簡単です。

Android DataCache


0

オブジェクトをあるアクティビティから別のアクティビティに渡すことができます。

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

0

あるアクティビティを別のアクティビティに渡します。

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

値を取得します。

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

-1

こんにちは、たくさんの良いオプションがありますが、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];
        }

    };
}

実際に参照をアクティビティからアクティビティに渡すため、このロジックは本当にすばらしいです。

nullのチェックと、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();

誰かがすべて狂ったようになり、この吸盤を真のジェネリックにすることができます。

弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.