Intents का उपयोग करके एक Android गतिविधि से दूसरे में एक वस्तु कैसे भेजें?

849

मैं कैसे एक से एक कस्टम प्रकार का ऑब्जेक्ट पारित कर सकते हैं गतिविधि का उपयोग कर किसी अन्य के लिए putExtra()वर्ग की विधि आशय ?

android  android-intent  android-activity 
— UMAR
स्रोत
@ सुम्मा - आपको अपने प्रश्नों को "सामुदायिक विकी" के रूप में चिह्नित करने की आवश्यकता नहीं है। एक नज़र यहाँ है: meta.stackexchange.com/questions/11740/…
— डेव वेब
1
@Peshesh: आपके द्वारा प्रदत्त लिंक टूट गया है। क्या आप एक विकल्प प्रदान कर सकते हैं?
— एंटीप्लेक्स
— ल्यूक
इस उत्तर को देखें। stackoverflow.com/questions/8857546/…
— Heitor Colangelo
मैं एक सरल और सुंदर विधि stackoverflow.com/a/37774966/6456129
— Yessy

जवाबों:

751

यदि आप सिर्फ वस्तुओं को इधर से उधर कर रहे हैं तो पार्सलबल को इसके लिए डिजाइन किया गया था। जावा के देशी क्रमांकन का उपयोग करने की तुलना में इसे थोड़ा अधिक प्रयास करने की आवश्यकता है, लेकिन यह तेज़ है (और मेरा मतलब है रास्ता, रास्ता तेज़ है)।

डॉक्स से, कैसे लागू करने के लिए एक सरल उदाहरण है:

// simple class that just has one member property as an example
public class MyParcelable implements Parcelable {
    private int mData;

    /* everything below here is for implementing Parcelable */

    // 99.9% of the time you can just ignore this
    @Override
    public int describeContents() {
        return 0;
    }

    // write your object's data to the passed-in Parcel
    @Override
    public void writeToParcel(Parcel out, int flags) {
        out.writeInt(mData);
    }

    // this is used to regenerate your object. All Parcelables must have a CREATOR that implements these two methods
    public static final Parcelable.Creator<MyParcelable> CREATOR = new Parcelable.Creator<MyParcelable>() {
        public MyParcelable createFromParcel(Parcel in) {
            return new MyParcelable(in);
        }

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

    // example constructor that takes a Parcel and gives you an object populated with it's values
    private MyParcelable(Parcel in) {
        mData = in.readInt();
    }
}

ध्यान दें कि यदि आपके पास दिए गए पार्सल से पुनर्प्राप्त करने के लिए एक से अधिक फ़ील्ड हैं, तो आपको यह उसी क्रम में करना होगा, जिस क्रम में आप उन्हें डालते हैं (जो कि, FIFO दृष्टिकोण में है)।

एक बार जब आप अपने ऑब्जेक्ट को लागू Parcelableयह सिर्फ उन्हें अपने में डाल की बात है उद्देश्य के साथ putExtra () :

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

फिर आप उन्हें getParcelableExtra () के साथ वापस खींच सकते हैं :

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

यदि आपकी ऑब्जेक्ट क्लास पार्सलेबल और सीरियल योग्य है, तो सुनिश्चित करें कि आप निम्न में से एक को कास्ट करते हैं:

i.putExtra("parcelable_extra", (Parcelable) myParcelableObject);
i.putExtra("serializable_extra", (Serializable) myParcelableObject);
— जेरेमी लोगान
स्रोत
14
यह कैसे लागू किया जाएगा जहां mData एक वस्तु है (जैसे JSONObject) और इंट नहीं?
— पीटर अज़ताई
301
इस सब के बिना वस्तु को पास क्यों नहीं किया जा सकता? हम एक ऑब्जेक्ट पास करना चाहते हैं जो पहले से ही मेमोरी में है।
— 6
110
@ क्
— मार्सिनज
12
अगर मैं ऑब्जेक्ट की श्रेणी को अनुक्रमिक या पारगम्य नहीं बना सकता तो मैं क्या करूं?
— एमिल जोस
11
@ceklock इसके पीछे का कारण इस प्रकार है: जब गतिविधि पीछे चली जाती है और बाद में मेमोरी से मार दी जाती है, और फिर जब उपयोगकर्ता इसे रीसेंट मेनू से खोलता है, तो इसे गतिविधि को बनाना होगा जहां इसे छोड़ा गया है। यह एक ही यूआई होना चाहिए। ऑब्जेक्ट इस मामले में मेमोरी में नहीं है। लेकिन इरादा है।
— तस्मानी
194

आपको किसी प्रकार के स्ट्रिंग प्रतिनिधित्व में अपनी वस्तु को क्रमबद्ध करना होगा। एक संभावित स्ट्रिंग प्रतिनिधित्व JSON है, और एंड्रॉइड में JSON से / के लिए अनुक्रमित करने के सबसे आसान तरीकों में से एक है, अगर आप मुझसे पूछते हैं, तो Google GSON के माध्यम से है ।

उस स्थिति में आप बस स्ट्रिंग वापसी मान डालते हैं और स्ट्रिंग मान (new Gson()).toJson(myObject);प्राप्त करते हैं और fromJsonइसे वापस अपनी वस्तु में बदलने के लिए उपयोग करते हैं।

यदि आपकी वस्तु बहुत जटिल नहीं है, हालांकि, यह ओवरहेड के लायक नहीं हो सकता है, और आप इसके बजाय ऑब्जेक्ट के अलग-अलग मूल्यों को पारित करने पर विचार कर सकते हैं।

— डेविड हेडलंड
स्रोत
19
मैं अनुमान लगा रहा हूं क्योंकि FiXedd का जवाब बाहरी पुस्तकालयों के उपयोग के बिना एक ही समस्या को हल करता है, एक तरह से जो बस इतना बेहतर है, कि किसी को भी मेरे द्वारा प्रदान किए गए समाधान से जाने का कोई कारण नहीं होना चाहिए (अनजान, उस समय, FiXedd का शानदार समाधान)
— डेविड
5
मुझे लगता है कि यह सही है। इसके अलावा, JSON क्लाइंट / सर्वर के लिए अधिक उपयुक्त प्रोटोकॉल है और थ्रेड-टू-थ्रेड नहीं है।
— mobibob
16
जरूरी नहीं कि एक बुरा विचार हो, esp। चूंकि गॉन उन सभी वस्तुओं के लिए उपयोग करने की तुलना में अधिक सरल है, जिन्हें आप भेजना चाहते हैं।
— uvesten
7
के रूप में iam मेरे अनुप्रयोग में gson का उपयोग कर यह एक बहुत आसान और अच्छा तरीका है!
— लार्स
16
अच्छा जवाब, हालांकि पूरा समाधान होगा String s = (new Gson().toJson(client));और फिरCli client = new Gson().fromJson(s, Cli.class);
— जोकिन इराचुक
155

आप आशय के माध्यम से क्रमिक वस्तु भेज सकते हैं

// send where details is object
ClassName details = new ClassName();
Intent i = new Intent(context, EditActivity.class);
i.putExtra("Editing", details);
startActivity(i);


//receive
ClassName model = (ClassName) getIntent().getSerializableExtra("Editing");

And 

Class ClassName implements Serializable {
}
— श्रीधर
स्रोत
2
आप पार्सलेबल आशय को भी भेज सकते हैं।
— टोनी गिल
6
"सीरियल एंड्रॉइड पर नाटकीय रूप से धीमा है। वास्तव में कई मामलों में बेकार। पर नज़र stackoverflow.com/questions/5550670/...
— सेराफिम के
यदि गतिविधि पहले से ही चल रही है, तो क्या प्रारंभ करने की आवश्यकता है (i); ? मेरा मतलब है, क्या मैं गतिविधि A को कॉल गतिविधि B बना सकता हूं , और वह गतिविधि A को डेटा लौटाता है ? क्या मैं भ्रमित हूँ?
— फ्रांसिस्को कॉर्लेस मोरालेस
3
@ यदि आप बहुत सी वस्तुओं को क्रमबद्ध कर रहे हैं तो Seraphim का प्रदर्शन मायने रखता है, लेकिन यदि कोई वस्तु 1 ms या 10 ms लेती है तो उपयोगकर्ता ध्यान नहीं देगा। यदि एक इरादे अतिरिक्त पहले से ही है, Serializableलेकिन ऐसा नहीं है Parcelable, तो यह इसे बनाने के लिए परेशानी के लायक है Parcelable।
— केविन क्रुमिडेव
67

उन स्थितियों के लिए जहां आप जानते हैं कि आप किसी एप्लिकेशन के भीतर डेटा पास कर रहे हैं, "ग्लोबल्स" का उपयोग करें (जैसे स्थिर कक्षाएं)

यहाँ क्या है डायने Hackborn : इस मामले पर कहना था - (क गूगल एंड्रॉयड सॉफ्टवेयर इंजीनियर hackbod)

उन स्थितियों के लिए जहां आप जानते हैं कि गतिविधियाँ एक ही प्रक्रिया में चल रही हैं, आप केवल ग्लोबल्स के माध्यम से डेटा साझा कर सकते हैं। उदाहरण के लिए, आपके पास एक वैश्विक हो सकता है HashMap<String, WeakReference<MyInterpreterState>> और जब आप एक नया MyInterpreterState बनाते हैं तो इसके लिए एक अनूठा नाम आता है और इसे हैश मैप में डाल दिया जाता है; उस स्थिति को किसी अन्य गतिविधि में भेजने के लिए, बस हैश मैप में अद्वितीय नाम डालें और दूसरी गतिविधि शुरू होने पर इसे प्राप्त होने वाले नाम के साथ हैश मैप से MyInterpreterState को पुनः प्राप्त कर सकते हैं।

— पीटर अज़ताई
स्रोत
25
हाँ, मुझे यह अजीब लगा कि हमें ये Intents उपयोग के लिए दिए गए हैं, और फिर एक शीर्ष इंजीनियर हमें बताता है कि बस हमारे डेटा के लिए ग्लोबल्स का उपयोग करें। लेकिन वहाँ यह घोड़ों के मुंह से सीधे है।
— रिचर्ड ले मेसियर 15
1
क्या कमजोर दुर्बलता यहां कचरा संग्रहण का शिकार नहीं होगी?
— २०
1
@ulysseus को लगता है कि यह विचार है, एक बार जब आप गतिविधियों में उनके साथ कर रहे हैं ... तो जब प्रासंगिक गतिविधियों को नष्ट कर दिया जाता है, तो यह इसे gc करने की अनुमति देगा
— पीटर Ajtai
1
@RichardLeMesurier मैं भी यही सोच रहा था, लेकिन फिर मैंने ऊपर संदर्भित Google समूह में डायने हैकॉर्न से पोस्ट किया, और उसने उल्लेख किया कि वास्तव में ग्लोबल्स के साथ एकमात्र मुद्दा अंतर्निहित इरादों का उपयोग करते समय होगा (जो आपके पैकेज के बाहर एक गतिविधि शुरू कर सकता है। )। यह समझ में आता है, जैसा कि डायने का उल्लेख है, क्योंकि उन गतिविधियों में उन कस्टम प्रकारों का शून्य ज्ञान होगा जो आप उनके पास से गुजर रहे हैं। एक बार जब मैंने पढ़ा कि, यह मेरे लिए यह स्पष्ट कर देता है कि ग्लोबल्स परिस्थितियों में इतना खराब मार्ग क्यों नहीं हो सकता है, और मुझे लगा कि मैं दूसरों को भी उत्सुक होने पर साझा करूंगा
— BMB
इरादों को एक ऐसे बिंदु पर ले जाया गया, जहां इरादे को एक अलग कंप्यूटर में पारित किया जा सकता था। जो स्पष्ट रूप से कुछ भी करने का एक अच्छा तरीका नहीं है जब आपके पास वास्तव में सिर्फ एक प्रक्रिया होती है जिसके बारे में आप सोचते हैं कि यह क्यों अच्छा नहीं है: स्मृति उपयोग, सीपीयू उपयोग, बैटरी उपयोग। पिछले एक विशेष रूप से डिजाइन के विकल्प के साथ बनाया गया था, जो कि काफी हद तक अस्पष्ट है। ऐसे लोग हैं जो जोर देते हैं कि वे एक अच्छा विचार हैं, आमतौर पर क्योंकि "Google ने ऐसा कहा था"।
— लस्सी किन्नुनेन
49

आपकी कक्षा को धारावाहिक या पार्सल लागू करना चाहिए।

public class MY_CLASS implements Serializable

एक बार जब आप putExtra पर एक वस्तु भेज सकते हैं

intent.putExtra("KEY", MY_CLASS_instance);

startActivity(intent);

एक्स्ट्रा पाने के लिए आपको सिर्फ करना होगा

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

यदि आपकी कक्षा अगले पार्सल को लागू करती है

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

मुझे आशा है कि यह मदद करता है: डी

— पेड्रो रोमियो को दर्शाता है
स्रोत
6
आपकी कक्षा को लागू Serializableकरना गलत है। वर्ग Parcelableउदाहरण के लिए लागू कर सकता है ।
— मार्क प्लानो-लेसे
Parcelable और Serializable @Kernald के बीच क्या अंतर हैं? प्रसंस्करण समय के संदर्भ में यह अधिक धीमी है / सर्वोत्तम अभ्यास या कुछ और नहीं?
— गमरु
जबकि Serializableएक मानक जावा इंटरफ़ेस है, Parcelableएंड्रॉइड-विशिष्ट है। प्रदर्शन के संदर्भ में, Parcelable अधिक कुशल है: developerphil.com/parcelable-vs-serializable
— मार्क प्लानो-लेसे
35

तेजी से जरूरत के लिए छोटा जवाब

1. अपनी कक्षा को अनुक्रमिक रूप से लागू करें।

यदि आपके पास कोई आंतरिक वर्ग है तो उन्हें भी सीरियल में लागू करना न भूलें !!

public class SportsData implements  Serializable
public class Sport implements  Serializable

List<Sport> clickedObj;

2. आब्जेक्ट में अपनी वस्तु डालें 

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

3. और अन्य गतिविधि वर्ग में अपनी वस्तु प्राप्त करें

Intent intent = getIntent();
    Sport cust = (Sport) intent.getSerializableExtra("sport");
— सैम
स्रोत
इस लिंक को देखें, stackoverflow.com/questions/2139134/…
— RejoylinLokeshwaran
आप पार्सलेबल इंटरफ़ेस लागू करके उसी चीज़ को प्राप्त कर सकते हैं। कोड आकार की वजह से पार्सलेबल इंटरफ़ेस को सीरियल की तुलना में लागू करने में अधिक समय लगता है। लेकिन यह सीरियल से बेहतर प्रदर्शन करता है और कम संसाधनों का उपयोग करता है।
— क्वाँस्टेंटिनो निकोल्सटोस
27

यदि आपकी ऑब्जेक्ट क्लास लागू होती है Serializable, तो आपको कुछ और करने की आवश्यकता नहीं है, आप एक सीरियल करने योग्य ऑब्जेक्ट पास कर सकते हैं।
यही मैं उपयोग करता हूं।

— व्लाद
स्रोत
24

अपनी कक्षा में क्रमिक लागू करें

public class Place implements Serializable{
        private int id;
        private String name;

        public void setId(int id) {
           this.id = id;
        }
        public int getId() {
           return id;
        }
        public String getName() {
           return name;
        }

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

तब आप इस वस्तु को आशय से पास कर सकते हैं

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

दूसरी गतिविधि int आप इस तरह से डेटा प्राप्त कर सकते हैं

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

लेकिन जब डेटा बड़ा हो जाएगा, तो यह विधि धीमी हो जाएगी।

— ईशान फर्नांडो
स्रोत
16

ऐसे कुछ तरीके हैं जिनके द्वारा आप अन्य वर्गों या गतिविधि में चर या ऑब्जेक्ट तक पहुंच सकते हैं।

ए। डेटाबेस

B. साझा प्राथमिकताएँ।

सी। वस्तु क्रमांकन।

डी। एक वर्ग जो सामान्य डेटा को धारण कर सकता है, उसे कॉमन यूटिलिटीज़ के रूप में नामित किया जा सकता है जो आप पर निर्भर करता है।

इंटेंस और पार्सलेबल इंटरफेस के माध्यम से ई पासिंग डेटा।

यह आपकी परियोजना की जरूरतों पर निर्भर करता है।

ए। डेटाबेस

SQLite एक Open Source Database है जो Android में सन्निहित है। SQLite SQL सिंटैक्स, लेन-देन और तैयार कथनों जैसे मानक संबंधपरक डेटाबेस सुविधाओं का समर्थन करता है।

ट्यूटोरियल - http://www.vogella.com/articles/AndroidSQLite/article.html

बी साझा प्राथमिकताएँ

मान लीजिए कि आप उपयोगकर्ता नाम संग्रहीत करना चाहते हैं। तो अब दो चीज़ होगी एक Key Username, Value Value।

कैसे स्टोर करें

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

सी। वस्तु क्रमांकन

ऑब्जेक्ट सेर्लाइज़ेशन का उपयोग किया जाता है यदि हम किसी वस्तु स्थिति को नेटवर्क पर भेजने के लिए सहेजना चाहते हैं या आप इसे अपने उद्देश्य के लिए भी उपयोग कर सकते हैं।

जावा बीन्स का उपयोग करें और अपने खेतों में से एक के रूप में स्टोर करें और उसके लिए गेटर्स और सेटर का उपयोग करें

जावाबाइन्स जावा वर्ग होते हैं जिनमें गुण होते हैं। गुणों को निजी उदाहरण चर के रूप में सोचें। चूंकि वे निजी हैं, इसलिए उनकी कक्षा के बाहर पहुंचने का एकमात्र तरीका कक्षा में विधियों के माध्यम से है। किसी संपत्ति के मूल्य को बदलने वाले तरीकों को सेटर विधियां कहा जाता है, और संपत्ति के मूल्य को पुनः प्राप्त करने वाले तरीकों को गेटर विधियां कहा जाता है।

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

फिर इस ऑब्जेक्ट को सीरियल करने के लिए ऑब्जेक्ट सीरियल का उपयोग करें और अपने अन्य वर्ग में इस ऑब्जेक्ट को डिसेरिएलाइज़ करें।

क्रमांकन में किसी ऑब्जेक्ट को बाइट्स के अनुक्रम के रूप में दर्शाया जा सकता है जिसमें ऑब्जेक्ट के डेटा के साथ-साथ ऑब्जेक्ट के प्रकार और ऑब्जेक्ट में संग्रहीत डेटा के प्रकार के बारे में जानकारी शामिल होती है।

किसी सीरियल किए गए ऑब्जेक्ट को किसी फ़ाइल में लिखे जाने के बाद, इसे फ़ाइल से पढ़ा जा सकता है और डीसर्विलाइज़ किया जा सकता है, जो कि प्रकार, सूचना और बाइट्स ऑब्जेक्ट का प्रतिनिधित्व करता है और इसके डेटा का उपयोग मेमोरी में ऑब्जेक्ट को फिर से बनाने के लिए किया जा सकता है।

यदि आप इसके लिए ट्यूटोरियल चाहते हैं तो इस लिंक को देखें

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

अन्य वर्गों में परिवर्तनशील हो

डी। आम उपयोगिताएँ

आप अपने स्वयं के द्वारा एक वर्ग बना सकते हैं जिसमें आम डेटा हो सकता है जिसकी आपको अपने प्रोजेक्ट में अक्सर आवश्यकता होती है।

नमूना

public class CommonUtilities {

    public static String className = "CommonUtilities";

}

इंटों के माध्यम से ई पासिंग डेटा

डेटा पास करने के इस विकल्प के लिए कृपया इस ट्यूटोरियल को देखें।

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

— निखिल अग्रवाल को दिखाया
स्रोत
इंटेंस के माध्यम से डेटा पास करने पर आप (ई) में उल्लेखित अच्छा ट्यूटोरियल।
— रेमीक
16

ऐसा करने के लिए आप Android BUNDLE का उपयोग कर सकते हैं।

अपनी कक्षा से एक बंडल बनाएं जैसे:

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

    return b;
}

फिर इस बंडल को INTENT के साथ पास करें। अब आप बंडल को पास करके अपनी कक्षा की वस्तु को फिर से बना सकते हैं

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

इसे अपने कस्टम वर्ग और उपयोग में घोषित करें।

— om252345
स्रोत
1
पार्सेबल कार्यान्वयन, IMHO को निर्देशित करने के लिए उपयुक्त है। बंडल अपने आप से पार्सलेबल लागू करता है ताकि आपके पास खुद को लागू करने में होने वाली सभी परेशानियों से बचने के दौरान प्रदर्शन का लाभ हो। इसके बजाय, आप डेटा को स्टोर करने और पुनः प्राप्त करने के लिए की-वैल्यू पेयर का उपयोग कर सकते हैं जो कि मात्र ऑर्डर पर निर्भर होने से कहीं अधिक मजबूत है।
— रिसादिंह
पार्सलबल मुझे जटिल लगता है, मेरे उपरोक्त उत्तर में मैं क्लास से टूंडल विधि का उपयोग कर रहा हूं, यह वस्तु पर है इसलिए ऑब्जेक्ट को बंडल में परिवर्तित किया जाता है और फिर हम बंडल को क्लास ऑब्जेक्ट में बदलने के लिए कंस्ट्रक्टर का उपयोग कर सकते हैं।
— om252345
यह समाधान केवल व्यवहार्य है यदि आप एक इरादे के माध्यम से एक ही वस्तु को पारित कर रहे हैं।
— आईआईटी
जैसे कि json लेकिन json हल्का वजन है जो मुझे लगता है।
— डेविड
क्या जब मैं इसे पुनः प्राप्त करूंगा तो वह वस्तु एक ही वस्तु या एक प्रति होगी?
— मार्कस
15

पार्सलबल मदद के लिए धन्यवाद, लेकिन मुझे एक और वैकल्पिक समाधान मिला 

 public class getsetclass implements Serializable {
        private int dt = 10;
    //pass any object, drwabale 
        public int getDt() {
            return dt;
        }

        public void setDt(int dt) {
            this.dt = dt;
        }
    }

एक्टिविटी वन में

getsetclass d = new getsetclass ();
                d.setDt(50);
                LinkedHashMap<String, Object> obj = new LinkedHashMap<String, Object>();
                obj.put("hashmapkey", d);
            Intent inew = new Intent(SgParceLableSampelActivity.this,
                    ActivityNext.class);
            Bundle b = new Bundle();
            b.putSerializable("bundleobj", obj);
            inew.putExtras(b);
            startActivity(inew);

गतिविधि 2 में डेटा प्राप्त करें

 try {  setContentView(R.layout.main);
            Bundle bn = new Bundle();
            bn = getIntent().getExtras();
            HashMap<String, Object> getobj = new HashMap<String, Object>();
            getobj = (HashMap<String, Object>) bn.getSerializable("bundleobj");
            getsetclass  d = (getsetclass) getobj.get("hashmapkey");
        } catch (Exception e) {
            Log.e("Err", e.getMessage());
        }
— user1140237
स्रोत
1
अच्छा जवाब है, लेकिन अपने कोडिंग मानकों को बढ़ाएं ... हालांकि प्रतियोगिता में सीरियल लाने के लिए +1 हालांकि पार्सल बहुत तेज़ हैं ...
— अमित
13

मैं गन्सन का उपयोग गतिविधियों के बीच वस्तुओं को भेजने के लिए अपने इतने शक्तिशाली और सरल एपी के साथ करता हूं,

उदाहरण

// This is the object to be sent, can be any object
public class AndroidPacket {

    public String CustomerName;

   //constructor
   public AndroidPacket(String cName){
       CustomerName = cName;
   }   
   // other fields ....


    // You can add those functions as LiveTemplate !
    public String toJson() {
        Gson gson = new Gson();
        return gson.toJson(this);
    }

    public static AndroidPacket fromJson(String json) {
        Gson gson = new Gson();
        return gson.fromJson(json, AndroidPacket.class);
    }
}

2 फ़ंक्शंस आप उन्हें उन ऑब्जेक्ट्स में जोड़ते हैं जिन्हें आप भेजना चाहते हैं

प्रयोग

A से B तक ऑब्जेक्ट भेजें

    // Convert the object to string using Gson
    AndroidPacket androidPacket = new AndroidPacket("Ahmad");
    String objAsJson = androidPacket.toJson();

    Intent intent = new Intent(A.this, B.class);
    intent.putExtra("my_obj", objAsJson);
    startActivity(intent);

B में प्राप्त करें

@Override
protected void onCreate(Bundle savedInstanceState) {        
    Bundle bundle = getIntent().getExtras();
    String objAsJson = bundle.getString("my_obj");
    AndroidPacket androidPacket = AndroidPacket.fromJson(objAsJson);

    // Here you can use your Object
    Log.d("Gson", androidPacket.CustomerName);
}

मैं इसका उपयोग लगभग हर परियोजना में करता हूं जो मेरे पास है और मेरे पास कोई प्रदर्शन समस्या नहीं है।

— MBH
स्रोत
धन्यवाद, इसने मुझे ओवरकंप्लिकेशन के घंटे बचाए।
— हिस्टोरो स्टॉयनोव
10

मैं उसी समस्या से जूझता रहा। मैंने इसे एक स्थैतिक वर्ग का उपयोग करके हल किया है, जो मैं चाहता हूं कि किसी भी डेटा को एक HashMap में संग्रहीत किया जाए। शीर्ष पर मैं मानक गतिविधि वर्ग के एक विस्तार का उपयोग करता हूं, जहां मैंने डेटा ट्रांसपोर्ट और डेटा क्लीयरिंग को करने के लिए ऑनड्रैस्ट्रॉय ऑन ऑन तरीकों को अपनाया है। कुछ हास्यास्पद सेटिंग्स को बदलना होगा जैसे कि अभिविन्यास-हैंडलिंग।

व्याख्या: किसी अन्य गतिविधि को पारित करने के लिए सामान्य वस्तुओं को प्रदान नहीं करना गधे में दर्द है। यह घुटने में खुद को गोली मारने और 100 मीटर जीतने की उम्मीद करने जैसा है। "Parcable" एक पर्याप्त विकल्प नहीं है। यह मुझे हँसाता है ... मैं इस इंटरफ़ेस को अपनी तकनीक-मुक्त एपीआई पर लागू नहीं करना चाहता, क्योंकि मैं एक नई परत शुरू करना चाहता हूं ... यह कैसे हो सकता है, कि हम मोबाइल प्रोग्रामिंग में इतनी दूर हैं आधुनिक प्रतिमान ...

— oopexpert
स्रोत
9

आपकी पहली गतिविधि में:

intent.putExtra("myTag", yourObject);

और आपके दूसरे में:

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

अपने कस्टम ऑब्जेक्ट को सीरियल बनाने योग्य मत भूलें: 

public class myCustomObject implements Serializable {
...
}
— रूडी
स्रोत
Parcelable Serializable से बेहतर है! अपने Android कोड में Serializable का उपयोग करने से बचें!
— ब्रिटो
7

ऐसा करने का दूसरा तरीका Applicationऑब्जेक्ट (android.app.Application) का उपयोग करना है । आप इसे इस रूप में परिभाषित करते हैं AndroidManifest.xml:

<application
    android:name=".MyApplication"
    ...

फिर आप इसे किसी भी गतिविधि से कॉल कर सकते हैं और ऑब्जेक्ट को Applicationकक्षा में सहेज सकते हैं ।

FirstActivity में:

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

सेकंडएक्टिविटी में, करें:

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

यह आसान है यदि आपके पास ऐसी वस्तुएं हैं जिनके पास आवेदन स्तर की गुंजाइश है यानी उन्हें पूरे आवेदन में उपयोग किया जाना है। Parcelableपद्धति अभी भी बेहतर आप वस्तु गुंजाइश पर स्पष्ट नियंत्रण या यदि गुंजाइश सीमित है चाहते हैं।

Intentsहालांकि यह पूरी तरह से उपयोग से बचें । मुझे नहीं पता कि वे आपके अनुरूप हैं। एक और तरीका है कि मैंने इसका उपयोग intवस्तुओं के पहचानकर्ताओं को इंटेंस के माध्यम से भेजने और उन ऑब्जेक्ट्स को पुनः प्राप्त करने के लिए किया है जो मेरे पास ऑब्जेक्ट में मैप्स में हैं Application।

— साद फारूक
स्रोत
1
वस्तुओं के परिवर्तनशील होने के बाद से चीजों को करने का यह सही तरीका नहीं है, अगर आप ऐप के जीवन चक्र के साथ स्थैतिक वस्तु के बारे में बात करते हैं, तो आप काम कर सकते हैं, लेकिन कुछ समय के लिए हमें ऐसी वस्तुओं की आवश्यकता होती है, जो webservice या so stackoverflow.com के
— मुहनाद ए। अलहरिरी
मैंने इसे एक अनुप्रयोग स्कोप द्वारा वेबसर्विसेज से उत्पन्न वस्तुओं के साथ सफलतापूर्वक उपयोग किया है Mapजहाँ पहचानकर्ता का उपयोग करके वस्तुओं को संग्रहीत और पुनर्प्राप्त किया जाता है। इस दृष्टिकोण के साथ एकमात्र वास्तविक समस्या यह है कि एंड्रॉइड कुछ समय बाद मेमोरी को साफ करता है ताकि आपको अपने onResume पर nulls की जांच करनी पड़े (मुझे लगता है कि इंटेंट्स में पास की गई वस्तुएं बनी हुई हैं लेकिन निश्चित नहीं हैं)। इसके अलावा मैं इसे काफी हीन होने के रूप में नहीं देखता।
— साद फारूक
यह सबसे अच्छा जवाब है। यह दिखाता है कि विभिन्न गतिविधियाँ एक ही डेटा मॉडल को कैसे संदर्भित कर सकती हैं। मुझे इसे खोजने में बहुत समय लगा!
— मार्कस
6

उदाहरण के लिए, अपने कक्षा मॉडल (ऑब्जेक्ट) को क्रमिक रूप से लागू करें:

public class MensajesProveedor implements Serializable {

    private int idProveedor;


    public MensajesProveedor() {
    }

    public int getIdProveedor() {
        return idProveedor;
    }

    public void setIdProveedor(int idProveedor) {
        this.idProveedor = idProveedor;
    }


}

और आपकी पहली गतिविधि 

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

और आपकी दूसरी गतिविधि (NewActivity)

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

सौभाग्य!!

— डेविड हैकरो का खुलासा किया
स्रोत
6 
public class SharedBooking implements Parcelable{

    public int account_id;
    public Double betrag;
    public Double betrag_effected;
    public int taxType;
    public int tax;
    public String postingText;

    public SharedBooking() {
        account_id = 0;
        betrag = 0.0;
        betrag_effected = 0.0;
        taxType = 0;
        tax = 0;
        postingText = "";
    }

    public SharedBooking(Parcel in) {
        account_id = in.readInt();
        betrag = in.readDouble();
        betrag_effected = in.readDouble();
        taxType = in.readInt();
        tax = in.readInt();
        postingText = in.readString();
    }

    public int getAccount_id() {
        return account_id;
    }
    public void setAccount_id(int account_id) {
        this.account_id = account_id;
    }
    public Double getBetrag() {
        return betrag;
    }
    public void setBetrag(Double betrag) {
        this.betrag = betrag;
    }
    public Double getBetrag_effected() {
        return betrag_effected;
    }
    public void setBetrag_effected(Double betrag_effected) {
        this.betrag_effected = betrag_effected;
    }
    public int getTaxType() {
        return taxType;
    }
    public void setTaxType(int taxType) {
        this.taxType = taxType;
    }
    public int getTax() {
        return tax;
    }
    public void setTax(int tax) {
        this.tax = tax;
    }
    public String getPostingText() {
        return postingText;
    }
    public void setPostingText(String postingText) {
        this.postingText = postingText;
    }
    public int describeContents() {
        // TODO Auto-generated method stub
        return 0;
    }
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeInt(account_id);
        dest.writeDouble(betrag);
        dest.writeDouble(betrag_effected);
        dest.writeInt(taxType);
        dest.writeInt(tax);
        dest.writeString(postingText);

    }

    public static final Parcelable.Creator<SharedBooking> CREATOR = new Parcelable.Creator<SharedBooking>()
    {
        public SharedBooking createFromParcel(Parcel in)
        {
            return new SharedBooking(in);
        }
        public SharedBooking[] newArray(int size)
        {
            return new SharedBooking[size];
        }
    };

}

डेटा पास करना:

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

डेटा पुनर्प्राप्त करना:

Bundle bundle = getIntent().getExtras();
dataList2 = getIntent().getExtras().getParcelableArrayList("data");
— अदनान अब्दुल्ला ज़की
स्रोत
5

सबसे आसान समाधान जो मुझे मिला है .. वह है स्टेटर्स के साथ स्थैतिक डेटा सदस्यों के साथ एक क्लास बनाना।

एक गतिविधि से सेट करें और दूसरी गतिविधि से प्राप्त करें जो ऑब्जेक्ट है।

गतिविधि ए

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

गतिविधि b

mytestclass obj= mytestclass.staticfunctionGet();
— UMAR
स्रोत
1
या क्रिएटिवल सेरेमेजेबल क्लास जो आप पास करना चाहते हैं, वह किसी अन्य गतिविधि को पास करने के लिए।
— उमर
9
बस बड़ी मोटी वस्तुओं को नहीं रखना याद रखें। उस वस्तु का जीवनकाल आवेदन के जीवनकाल के समान ही होगा। और कभी भी विचार संग्रहीत न करें। यह विधि मेमोरी लीक की गारंटी भी देती है।
— रेनो
1
यह उत्तर उपयोगी है, लेकिन स्मृति और संसाधन अनुकूलन के मामले में बेहतर समाधान नहीं है
— अतुल भारद्वाज
1
यह वैश्विक चर पेश करके ओओपी सिद्धांतों को तोड़ता है। आप कभी नहीं जानते हैं कि वे किस राज्य में हैं, चाहे वे सेट हों या नहीं, उनका उपयोग कई थ्रेड द्वारा किया जाता है और आपको इस जटिलता से निपटना पड़ता है। यह आम तौर पर एक अच्छा मेमोरी लीक है, क्योंकि आपको पता भी नहीं है कि इन चरों को कब मुक्त करना है। यह कहने के लिए नहीं कि यह एप्लिकेशन के विभिन्न मॉड्यूलों के बीच कठिन प्रत्यक्ष युग्मन का परिचय देता है।
— 13
2
WTF? अन्य दो उत्तर बहुत श्रेष्ठ हैं।
— IcyFlame
4

आप अपने वर्ग प्रकार की वस्तुओं को पास और पुनः प्राप्त करने के लिए putExtra (Serializable ..) और getSerializableExtra () विधियों का उपयोग कर सकते हैं; आपको अपनी कक्षा को क्रमिक रूप से चिह्नित करना होगा और यह सुनिश्चित करना होगा कि आपके सभी सदस्य चर भी धारावाहिक हैं ...

— शून्य
स्रोत
4

Android एप्लिकेशन बनाएं

फ़ाइल >> नया >> एंड्रॉइड एप्लीकेशन

प्रोजेक्ट नाम दर्ज करें: Android-पास-ऑब्जेक्ट-टू-एक्टिविटी

Pakcage: com.hmkcode.android

अन्य अवशिष्ट चयन रखें, जब तक आप समाप्त नहीं हो जाते तब तक अगला जाएं

एप्लिकेशन बनाने से पहले हमें POJO वर्ग "व्यक्ति" बनाने की आवश्यकता है जिसका उपयोग हम एक गतिविधि से दूसरी वस्तु पर भेजने के लिए करेंगे। ध्यान दें कि वर्ग सीरियल इंटरफ़ेस लागू कर रहा है।

Person.java

package com.hmkcode.android;
import java.io.Serializable;

public class Person implements Serializable{

    private static final long serialVersionUID = 1L;

    private String name;
    private int age;

        // getters & setters....

    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }   
}

दो गतिविधियों के लिए दो लेआउट

activity_main.xml

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical"
tools:context=".MainActivity" >

<LinearLayout
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:orientation="horizontal">
    <TextView
        android:id="@+id/tvName"
        android:layout_width="100dp"
        android:layout_height="wrap_content"
        android:layout_gravity="center"
        android:gravity="center_horizontal"
        android:text="Name" />

    <EditText
        android:id="@+id/etName"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"

        android:ems="10" >
        <requestFocus />
    </EditText>
</LinearLayout>

<LinearLayout
     android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:orientation="horizontal">
<TextView
    android:id="@+id/tvAge"
    android:layout_width="100dp"
    android:layout_height="wrap_content"
    android:layout_gravity="center"
    android:gravity="center_horizontal"
    android:text="Age" />
<EditText
    android:id="@+id/etAge"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:ems="10" />
</LinearLayout>

<Button
    android:id="@+id/btnPassObject"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:layout_gravity="center_horizontal"
    android:text="Pass Object to Another Activity" />

</LinearLayout>

activity_another.xml

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical"
 >

<TextView
    android:id="@+id/tvPerson"
    android:layout_height="wrap_content"
    android:layout_width="fill_parent"
    android:layout_gravity="center"
    android:gravity="center_horizontal"
 />

</LinearLayout>

दो गतिविधि कक्षाएं

1) ActivityMain.java

package com.hmkcode.android;

import android.os.Bundle;
import android.app.Activity;
import android.content.Intent;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.EditText;

public class MainActivity extends Activity implements OnClickListener {

Button btnPassObject;
EditText etName, etAge;
@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    btnPassObject = (Button) findViewById(R.id.btnPassObject);
    etName = (EditText) findViewById(R.id.etName);
    etAge = (EditText) findViewById(R.id.etAge);

    btnPassObject.setOnClickListener(this);
}

@Override
public void onClick(View view) {

    // 1. create an intent pass class name or intnet action name 
    Intent intent = new Intent("com.hmkcode.android.ANOTHER_ACTIVITY");

    // 2. create person object
    Person person = new Person();
    person.setName(etName.getText().toString());
    person.setAge(Integer.parseInt(etAge.getText().toString()));

    // 3. put person in intent data
    intent.putExtra("person", person);

    // 4. start the activity
    startActivity(intent);
}

}

2) AnotherActivity.java

package com.hmkcode.android;

import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.widget.TextView;

public class AnotherActivity extends Activity {

TextView tvPerson;

@Override
protected void onCreate(Bundle savedInstanceState) {
    // TODO Auto-generated method stub
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_another);

    // 1. get passed intent 
    Intent intent = getIntent();

    // 2. get person object from intent
    Person person = (Person) intent.getSerializableExtra("person");

    // 3. get reference to person textView 
    tvPerson = (TextView) findViewById(R.id.tvPerson);

    // 4. display name & age on textView 
    tvPerson.setText(person.toString());

}
}
— एमएफपी
स्रोत
4

Google की Gson लाइब्रेरी का उपयोग करके आप अन्य गतिविधियों के लिए ऑब्जेक्ट पास कर सकते हैं। आमतौर पर हम ऑब्जेक्ट को json string के रूप में परिवर्तित करेंगे और अन्य गतिविधि के पास होने के बाद हम फिर से ऑब्जेक्ट को इस तरह से परिवर्तित करेंगे।

इस तरह से एक बीन क्लास पर विचार करें

 public class Example {
    private int id;
    private String name;

    public Example(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

हमें उदाहरण वर्ग का ऑब्जेक्ट पास करना होगा

Example exampleObject=new Example(1,"hello");
String jsonString = new Gson().toJson(exampleObject);
Intent nextIntent=new Intent(this,NextActivity.class);
nextIntent.putExtra("example",jsonString );
startActivity(nextIntent);

पढ़ने के लिए हमें NextActivity में रिवर्स ऑपरेशन करना होगा

 Example defObject=new Example(-1,null);
    //default value to return when example is not available
    String defValue= new Gson().toJson(defObject);
    String jsonString=getIntent().getExtras().getString("example",defValue);
    //passed example object
    Example exampleObject=new Gson().fromJson(jsonString,Example .class);

इस निर्भरता को प्रवणता में जोड़ें

compile 'com.google.code.gson:gson:2.6.2'
— जिनेश फ्रांसिस
स्रोत
3

मुझे पता है कि यह देर हो चुकी है, लेकिन यह बहुत आसान है। आपके पास ऐसा करने के लिए अपनी कक्षा को सीरियल की तरह लागू करने दें

public class MyClass implements Serializable{

}

तब आप जैसे इरादे को पास कर सकते हैं

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

इसे प्राप्त करने के लिए आप सरल कॉल करें 

MyClass objec=(MyClass)intent.getExtra("theString");
— suulisin
स्रोत
2

यदि आपके पास वैसे भी आपकी मॉडल परत के प्रवेश द्वार के रूप में अभिनय करने वाला एक एकल वर्ग (fx Service) है, तो इसे गेटर्स के साथ उस वर्ग में एक चर होने और इसके लिए बसने से हल किया जा सकता है।

गतिविधि 1 में:

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

गतिविधि 2 में:

private Service service;
private Order order;

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

    service = Service.getInstance();
    order = service.getSavedOrder();
    service.setSavedOrder(null) //If you don't want to save it for the entire session of the app.
}

सेवा में:

private static Service instance;

private Service()
{
    //Constructor content
}

public static Service getInstance()
{
    if(instance == null)
    {
        instance = new Service();
    }
    return instance;
}
private Order savedOrder;

public Order getSavedOrder()
{
    return savedOrder;
}

public void setSavedOrder(Order order)
{
    this.savedOrder = order;
}

इस समाधान को प्रश्न में किसी भी क्रमांकन या अन्य "पैकेजिंग" की आवश्यकता नहीं है। लेकिन यह केवल तभी फायदेमंद होगा जब आप इस तरह की वास्तुकला का उपयोग कर रहे हों।

— Kitalda
स्रोत
इस दृष्टिकोण के नीचे क्या हैं? यह इतना तार्किक और पतला लगता है। मैंने हमेशा पढ़ा है कि आपको ऐसा नहीं करना चाहिए लेकिन मुझे कभी भी इस बारे में अच्छी व्याख्या नहीं मिली कि क्या गलत हो सकता है।
— मार्कस
चूंकि अब मैं अपनी टिप्पणी संपादित नहीं कर सकता: क्या यह एक प्रतिलिपि के बजाय किसी ऑब्जेक्ट का संदर्भ प्राप्त करने का एकमात्र संभव समाधान नहीं है? मैं एक ही obejct को पुनः प्राप्त करने की आवश्यकता है और एक प्रति नहीं!
— मार्कस
मुझे लगता है कि उच्च युग्मन के कारण यह कुछ हद तक हतोत्साहित करता है। लेकिन हाँ, जहाँ तक मैं देख सकता हूँ, यह दृष्टिकोण सबसे व्यवहार्य है अगर आपको वास्तविक वस्तु की आवश्यकता है। प्रोग्रामिंग में हमेशा की तरह, आप जो चाहें कर सकते हैं, आप बस इसे सावधानी से करना चाहते हैं। इस समाधान ने मेरे लिए काम किया, और मैं इसे पसंद करता हूं क्योंकि मैं उस वास्तुकला का उपयोग करता हूं।
— कितालदा
वास्तव में मैंने एप्लीकेशन क्लास का विस्तार किया और अपना डेटामोडेल वहाँ जमा किया। इंटेंट्स में मैंने केवल उन डेटा ऑब्जेक्ट्स की आईडी को रिले किया, जिनका उपयोग एप्लिकेशन क्लास से मूल ऑब्जेक्ट को प्राप्त करने के लिए किया जा सकता है। साथ ही विस्तारित एप्लिकेशन क्लास उन सभी ऑब्जेक्ट्स को सूचित करता है जो डेटामॉडल का उपयोग करते हैं यदि यह मानक श्रोता अवधारणा के माध्यम से बदलता है। मुझे पता है कि यह केवल मेरे मामले में फिट बैठता है जहां मुझे पूरे आवेदन पर डेटामॉडल साझा करने की आवश्यकता है, लेकिन उस मामले के लिए इसकी सही और कोई स्थिर वर्ग और फ़ील्ड भी आवश्यक नहीं है!
— मार्कस
2

अब तक पार्सल वस्तुओं के लिए सबसे आसान तरीका IMHO है। आप बस उस वस्तु के ऊपर एक एनोटेशन टैग जोड़ते हैं जिसे आप पार्सल करने की इच्छा रखते हैं।

लाइब्रेरी का एक उदाहरण https://github.com/johncarl81/parceler के नीचे है

@Parcel
public class Example {
    String name;
    int age;

    public Example(){ /*Required empty bean constructor*/ }

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

    public String getName() { return name; }

    public int getAge() { return age; }
}
— रयान
स्रोत
2

सबसे पहले अपनी कक्षा में Parcelable को लागू करें। फिर वस्तु को इस तरह पास करें।

SendActivity.java

ObjectA obj = new ObjectA();

// Set values etc.

Intent i = new Intent(this, MyActivity.class);
i.putExtra("com.package.ObjectA", obj);

startActivity(i);

ReceiveActivity.java

Bundle b = getIntent().getExtras();
ObjectA obj = b.getParcelable("com.package.ObjectA");

पैकेज स्ट्रिंग आवश्यक नहीं है, बस स्ट्रिंग को दोनों गतिविधियों में समान होना चाहिए

संदर्भ

— अर्पित पटेल
स्रोत
2

इस गतिविधि से एक और गतिविधि शुरू करें बंडल ऑब्जेक्ट के माध्यम से पैरामीटर पास करें

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);
— user1101821
स्रोत
2

कोल्टिन में

अपने build.gradle में कोटलिन एक्सटेंशन जोड़ें।

apply plugin: 'kotlin-android-extensions'

android {
    androidExtensions {
        experimental = true
   }
}

फिर इस तरह अपना डेटा क्लास बनाएं।

@Parcelize
data class Sample(val id: Int, val name: String) : Parcelable

आशय के साथ पास वस्तु 

val sample = Sample(1,"naveen")

val intent = Intent(context, YourActivity::class.java)
    intent.putExtra("id", sample)
    startActivity(intent)

आशय से वस्तु प्राप्त करो

val sample = intent.getParcelableExtra("id")
— नवीन
स्रोत
क्या यह अभी भी प्रायोगिक है?
— ShadeToD
2

करने का सबसे आसान और जावा तरीका है: अपने पूजो / मॉडल वर्ग में क्रमबद्धता को लागू करना

प्रदर्शन दृश्य के लिए Android के लिए अनुशंसित: मॉडल को पार्सल योग्य बनाएं

— अशोक कुमार
स्रोत
1

सबसे सरल सिर्फ निम्नलिखित का उपयोग करना होगा जहां आइटम एक स्ट्रिंग है:

intent.putextra("selected_item",item)

प्राप्त करने के लिए:

String name = data.getStringExtra("selected_item");
— akish
स्रोत
3
स्ट्रिंग, पूर्णांक और आदि के लिए ही, लेकिन मैं वस्तु चाहता हूं और स्थिर वस्तु का उपयोग करना संभव है।
— उमार
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.