ऐड (), रिप्लेस () और ऐडटैकबैकस्टैक () के बीच अंतर

300

इन तरीकों को कॉल करने के बीच मुख्य अंतर क्या है:

fragmentTransaction.addToBackStack(name);
fragmentTransaction.replace(containerViewId, fragment, tag);
fragmentTransaction.add(containerViewId, fragment, tag);

पहले से मौजूद टुकड़े को बदलने के लिए, और गतिविधि राज्य में एक टुकड़ा जोड़ने, और पीछे के ढेर में एक गतिविधि जोड़ने का क्या मतलब है?

दूसरी बात, findFragmentByTag()क्या यह add()/ / replace()विधि द्वारा जोड़े गए टैग के लिए खोज करता है addToBackStack()?

android android-fragments

— AndroidDev
स्रोत

330

1) fragmentTransaction.addToBackStack(str);

विवरण - इस लेनदेन को बैक स्टैक में जोड़ें। इसका मतलब यह है कि लेनदेन को प्रतिबद्ध होने के बाद याद किया जाएगा, और जब बाद में स्टैक को पॉपअप किया जाता है, तो इसका संचालन उलट जाएगा।

2) fragmentTransaction.replace(int containerViewId, Fragment fragment, String tag)

विवरण - एक मौजूदा टुकड़े को बदलें जो एक कंटेनर में जोड़ा गया था। यह अनिवार्य रूप से वर्तमान में जोड़े गए सभी अंशों के लिए कॉल हटाने (फ्रेगमेंट) के समान है जो कि एक ही कंटेनर व्यूआईड के साथ जोड़े गए थे और फिर यहां दिए गए समान तर्कों के साथ (int, Fragment, String) जोड़ें।

3) fragmentTransaction.add(int containerViewId, Fragment fragment, String tag)

विवरण - गतिविधि राज्य में एक टुकड़ा जोड़ें। यह टुकड़ा वैकल्पिक रूप से भी अपना दृश्य हो सकता है (यदि Fragment.onCreateView गैर-शून्य देता है) गतिविधि के एक कंटेनर दृश्य में।

पहले से मौजूद टुकड़े को बदलने के लिए, और गतिविधि राज्य में एक टुकड़ा जोड़ने और बैक स्टैक में एक गतिविधि जोड़ने का क्या मतलब है?

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

आप मल्टी-फलक UI बनाने के लिए एक एकल गतिविधि में कई टुकड़े जोड़ सकते हैं और कई गतिविधियों में एक टुकड़े का पुन: उपयोग कर सकते हैं। यह आवश्यक रूप से उपयोगी है जब आपने अपने टुकड़े कंटेनर को विभिन्न लेआउट में परिभाषित किया है। आपको बस किसी भी अन्य टुकड़े को किसी भी लेआउट में बदलने की आवश्यकता है।

जब आप वर्तमान लेआउट पर नेविगेट करते हैं, तो आपके पास उस कंटेनर की आईडी होती है, जिसे आप उस टुकड़े से बदलना चाहते हैं।

आप popBackStack()विधि के साथ बैकस्टैक में पिछले टुकड़े पर भी जा सकते हैं । इसके लिए आपको स्टैक का उपयोग करके addToBackStack()और फिर commit()प्रतिबिंबित करने के लिए उस टुकड़े को जोड़ना होगा । यह शीर्ष पर वर्तमान के साथ रिवर्स ऑर्डर में है।

findFragmentByTag यह टैग ऐड / रिप्लेसमेंट मेथड या addTBBackStack मेथड द्वारा जोड़े गए टैग की खोज करता है?

यदि आप इस पर निर्भर करते हैं कि आपने टैग कैसे जोड़ा है। इसके बाद इसके टैग से एक टुकड़ा मिलता है जिसे आपने एक्सएमएल से फुलाए जाने पर या लेन-देन में जोड़े जाने पर आपूर्ति से पहले परिभाषित किया था।

संदर्भ: विखंडन

— हे भगवान
स्रोत

2

तो, क्या मैं शुरू की गई गतिविधि में विधि द्वारा प्रतिस्थापित करके टुकड़ा जोड़ सकता हूं?

— योहन एआई

(इससे पहले कोई टुकड़ा नहीं जोड़ा गया था)

— योहन एआई

2

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

— वेद

1

@ नहीं नहीं, यह वर्तमान में कंटेनर में मौजूदा सभी टुकड़ों को बदल देगा।

— जुबांझोन

329

के बीच एक और महत्वपूर्ण अंतर addऔर replaceयह है:

replaceमौजूदा टुकड़े को हटाता है और एक नया टुकड़ा जोड़ता है। इसका मतलब यह है कि जब आप बैक बटन दबाते हैं, तो जो टुकड़ा मिला है, वह उसके onCreateViewचालान के साथ बनाया जाएगा । जबकि addमौजूदा अंशों को बरकरार रखता है और एक नया टुकड़ा जोड़ता है जिसका अर्थ है कि मौजूदा टुकड़ा सक्रिय होगा और वे 'रुके हुए' अवस्था में नहीं होंगे इसलिए जब एक बैक बटन दबाया onCreateViewजाता है तो उसे मौजूदा टुकड़े के लिए नहीं बुलाया जाता है (जो टुकड़ा नए टुकड़े से पहले था। जोड़ा)।

टुकड़ा के जीवन चक्र की घटनाओं के संदर्भ में onPause, onResume, onCreateViewऔर अन्य जीवन चक्र घटनाओं के मामले में सक्रिय किया जाएगा replace, लेकिन वे के मामले में लागू किया जा नहीं होते add।

संपादित करें : एक को सावधान रहना चाहिए यदि वह किसी प्रकार की ईवेंट बस लाइब्रेरी का उपयोग कर रहा है जैसे कि ग्रीनब्रोट का इवेंटबस और उसी टुकड़े को दूसरे के माध्यम से टुकड़े को ढेर करने के लिए पुन: उपयोग करना add। इस परिदृश्य में, भले ही आप सबसे अच्छे अभ्यास का पालन करते हैं और ईवेंट बस को इन-रजिस्टर onResumeऔर अनरजिस्टर्ड में पंजीकृत करते हैं onPause, ईवेंट बस अभी भी जोड़े गए टुकड़े के प्रत्येक उदाहरण में सक्रिय रहेगा, क्योंकि addइन खंडित जीवन चक्र विधियों में से कोई भी कॉल न करें। परिणामस्वरूप घटना के प्रत्येक सक्रिय उदाहरण में बस श्रोता उसी घटना को संसाधित करेगा, जो आप नहीं चाहते हैं।

— जीवन
स्रोत

1

मुझे लगता है कि प्रक्रिया पूरी होने के बाद सबसे अधिक अंश में घटना को संसाधित करने और कॉल रद्द करने की कोशिश हो सकती है। आप CancelEventDelivery () मेथड्स github.com/greenrobot/EventBus/blob/master/…

— Jeevan

6

मुझ से +1। यह जानना बहुत महत्वपूर्ण है कि नए टुकड़े के साथ वर्तमान टुकड़े की जगह, इसका मतलब है कि पिछले टुकड़े को फिर से प्राप्त करने के लिए फिर से बनाया जाएगा जब टुकड़े के ढेर से वापस पॉपिंग हो।

— अंडालूज

onPause, onResume कसकर Host गतिविधि से जुड़ा है। और उन्होंने जब टुकड़े की जगह नहीं ली।

— ज़ार ई अहमर

बस इसे जोड़ने के लिए, यदि आप EventBus का उपयोग कर रहे हैं, तो आप टैग के साथ टुकड़ा जोड़ सकते हैं, और उस टैग से उस इवेंट में पास हो सकते हैं, और वैसे भी चेक कर सकते हैं, सभी इवेंटबस को कॉल किया जाएगा, आप बस निर्दिष्ट करें कि कौन सा निष्पादित करना चाहिए

— user2581818

आपको यह उल्लेख करना होगा कि आप addToBackStack () को add () या प्रतिस्थापित () विधियों के साथ कॉल कर रहे हैं।

— rahil008

99

उदाहरण के लिए एक गतिविधि के 2 टुकड़े होते हैं और जिनका उपयोग हम FragmentManagerबदलने / जोड़ने के लिए करते हैंaddToBackstack प्रत्येक टुकड़े के गतिविधि में एक लेआउट में

बदलें का उपयोग करें

जाओ Fragment1

Fragment1: onAttach
Fragment1: onCreate
Fragment1: onCreateView
Fragment1: onActivityCreated
Fragment1: onStart
Fragment1: onResume

जाओ Fragment2

Fragment2: onAttach
Fragment2: onCreate
Fragment1: onPause
Fragment1: onStop
Fragment1: onDestroyView
Fragment2: onCreateView
Fragment2: onActivityCreated
Fragment2: onStart
Fragment2: onResume

पॉप फ्रैगमेंट 2

Fragment2: onPause
Fragment2: onStop
Fragment2: onDestroyView
Fragment2: onDestroy
Fragment2: onDetach
Fragment1: onCreateView
Fragment1: onStart
Fragment1: onResume

पॉप फ्रैगमेंट १

Fragment1: onPause
Fragment1: onStop
Fragment1: onDestroyView
Fragment1: onDestroy
Fragment1: onDetach

ऐड का उपयोग करें

जाओ Fragment1

Fragment1: onAttach
Fragment1: onCreate
Fragment1: onCreateView
Fragment1: onActivityCreated
Fragment1: onStart
Fragment1: onResume

जाओ Fragment2

Fragment2: onAttach
Fragment2: onCreate
Fragment2: onCreateView
Fragment2: onActivityCreated
Fragment2: onStart
Fragment2: onResume

पॉप फ्रैगमेंट 2

Fragment2: onPause
Fragment2: onStop
Fragment2: onDestroyView
Fragment2: onDestroy
Fragment2: onDetach

पॉप फ्रैगमेंट १

Fragment1: onPause
Fragment1: onStop
Fragment1: onDestroyView
Fragment1: onDestroy
Fragment1: onDetach

नमूना परियोजना

— फान वान लिंह
स्रोत

1

प्रत्येक पॉप कार्रवाई पर onPause()पहले बुलाया नहीं जाना चाहिए था ? onStop()

— iCCC

AddToBackStack () के बारे में याद करते हुए, हालांकि 'ऐड ()' और 'रिप्लेस ()' के बीच अंतर करने के लिए उत्कृष्ट उत्तर। वोट दें

— शिरीष Herwade

@SishishHerwade मेरा मानना है कि उन्होंने दोनों मामलों में addToBackStack के साथ ऐड और रिप्लेस के बीच अंतर प्रदर्शित किया।

— साइबरशॉक

38

हालांकि यह पहले से ही उत्तर दिया गया एक पुराना प्रश्न है, हो सकता है कि अगले उदाहरण स्वीकार किए गए उत्तर को पूरक कर सकें और वे Android में कुछ नए प्रोग्रामर के लिए उपयोगी हो सकते हैं जैसे मैं हूं।

विकल्प 1 - "addToBackStack ()" का उपयोग कभी नहीं किया जाता है

केस 1 ए - बैक बटन जोड़ना, हटाना और क्लिक करना

Activity :      onCreate() - onStart() - onResume()                             Activity is visible
add Fragment A :    onAttach() - onCreate() - onCreateView() - onActivityCreated() - onStart() - onResume()     Fragment A is visible
add Fragment B :    onAttach() - onCreate() - onCreateView() - onActivityCreated() - onStart() - onResume()     Fragment B is visible
add Fragment C :    onAttach() - onCreate() - onCreateView() - onActivityCreated() - onStart() - onResume()     Fragment C is visible
remove Fragment C :     onPause() - onStop() - onDestroyView() - onDestroy() - onDetach()               Fragment B is visible
(Back button clicked)
Activity :      onPause() - onStop() - onDestroy()
Fragment A :        onPause() - onStop() - onDestroyView() - onDestroy() - onDetach()
Fragment B :        onPause() - onStop() - onDestroyView() - onDestroy() - onDetach()               App is closed, nothing is visible

केस 1 बी - बैक बटन जोड़ना, बदलना और क्लिक करना

Activity :      onCreate() - onStart() - onResume()                             Activity is visible
add Fragment A :    onAttach() - onCreate() - onCreateView() - onActivityCreated() - onStart() - onResume()     Fragment A is visible
add Fragment B :    onAttach() - onCreate() - onCreateView() - onActivityCreated() - onStart() - onResume()     Fragment B is visible
(replace Fragment C)    
Fragment B :        onPause() - onStop() - onDestroyView() - onDestroy() - onDetach()               
Fragment A :        onPause() - onStop() - onDestroyView() - onDestroy() - onDetach()
Fragment C :        onAttach() - onCreate() - onCreateView() - onActivityCreated() - onStart() - onResume()     Fragment C is visible
(Back button clicked)
Activity :      onPause() - onStop() - onDestroy()
Fragment C :        onPause() - onStop() - onDestroyView() - onDestroy() - onDetach()               App is closed, nothing is visible

विकल्प 2 - "addToBackStack ()" हमेशा उपयोग किया जाता है

केस 2A - बैक बटन जोड़ना, हटाना और क्लिक करना

Activity :      onCreate() - onStart() - onResume()                             Activity is visible
add Fragment A :    onAttach() - onCreate() - onCreateView() - onActivityCreated() - onStart() - onResume()     Fragment A is visible
add Fragment B :    onAttach() - onCreate() - onCreateView() - onActivityCreated() - onStart() - onResume()     Fragment B is visible
add Fragment C :    onAttach() - onCreate() - onCreateView() - onActivityCreated() - onStart() - onResume()     Fragment C is visible
remove Fragment C :     onPause() - onStop() - onDestroyView()                              Fragment B is visible
(Back button clicked)
Fragment C :        onCreateView() - onActivityCreated() - onStart() - onResume()                   Fragment C is visible
(Back button clicked)
Fragment C :        onPause() - onStop() - onDestroyView() - onDestroy() - onDetach()               Fragment B is visible
(Back button clicked)
Fragment B :        onPause() - onStop() - onDestroyView() - onDestroy() - onDetach()               Fragment A is visible
(Back button clicked)
Fragment A :        onPause() - onStop() - onDestroyView() - onDestroy() - onDetach()               Activity is visible
(Back button clicked)
Activity :      onPause() - onStop() - onDestroy()                              App is closed, nothing is visible

केस 2 बी - बैक बटन जोड़ना, बदलना, हटाना और क्लिक करना

Activity :      onCreate() - onStart() - onResume()                             Activity is visible
add Fragment A :    onAttach() - onCreate() - onCreateView() - onActivityCreated() - onStart() - onResume()     Fragment A is visible
add Fragment B :    onAttach() - onCreate() - onCreateView() - onActivityCreated() - onStart() - onResume()     Fragment B is visible
(replace Fragment C)    
Fragment B :        onPause() - onStop() - onDestroyView()  
Fragment A :        onPause() - onStop() - onDestroyView() 
Fragment C :        onAttach() - onCreate() - onCreateView() - onActivityCreated() - onStart() - onResume()     Fragment C is visible
remove Fragment C :     onPause() - onStop() - onDestroyView()                              Activity is visible
(Back button clicked)
Fragment C :        onCreateView() - onActivityCreated() - onStart() - onResume()                   Fragment C is visible
(Back button clicked)
Fragment C :        onPause() - onStop() - onDestroyView() - onDestroy() - onDetach()               
Fragment A :        onCreateView() - onActivityCreated() - onStart() - onResume()   
Fragment B :        onCreateView() - onActivityCreated() - onStart() - onResume()                   Fragment B is visible
(Back button clicked)
Fragment B :        onPause() - onStop() - onDestroyView() - onDestroy() - onDetach()               Fragment A is visible
(Back button clicked)
Fragment A :        onPause() - onStop() - onDestroyView() - onDestroy() - onDetach()               Activity is visible
(Back button clicked)
Activity :      onPause() - onStop() - onDestroy()                              App is closed, nothing is visible

विकल्प 3 - "addToBackStack ()" का उपयोग हमेशा नहीं किया जाता है (नीचे के उदाहरणों में, w / o इंगित करता है कि इसका उपयोग नहीं किया गया है)

केस 3 ए - बैक बटन जोड़ना, हटाना और क्लिक करना

Activity :      onCreate() - onStart() - onResume()                             Activity is visible
add Fragment A :    onAttach() - onCreate() - onCreateView() - onActivityCreated() - onStart() - onResume()     Fragment A is visible
add Fragment B w/o:     onAttach() - onCreate() - onCreateView() - onActivityCreated() - onStart() - onResume()     Fragment B is visible
add Fragment C w/o:     onAttach() - onCreate() - onCreateView() - onActivityCreated() - onStart() - onResume()     Fragment C is visible
remove Fragment C :     onPause() - onStop() - onDestroyView() - onDestroy() - onDetach()               Fragment B is visible
(Back button clicked)
Fragment B :        onPause() - onStop() - onDestroyView() - onDestroy() - onDetach()               
Fragment A :        onPause() - onStop() - onDestroyView() - onDestroy() - onDetach()               Activity is visible
(Back button clicked)
Activity :      onPause() - onStop() - onDestroy()                              App is closed, nothing is visible

केस 3 बी - बैक बटन जोड़ना, बदलना, हटाना और क्लिक करना

Activity :      onCreate() - onStart() - onResume()                             Activity is visible
add Fragment A :    onAttach() - onCreate() - onCreateView() - onActivityCreated() - onStart() - onResume()     Fragment A is visible
add Fragment B w/o:     onAttach() - onCreate() - onCreateView() - onActivityCreated() - onStart() - onResume()     Fragment B is visible
(replace Fragment C)    
Fragment B :        onPause() - onStop() - onDestroyView() - onDestroy() - onDetach()   
Fragment A :        onPause() - onStop() - onDestroyView() 
Fragment C :        onAttach() - onCreate() - onCreateView() - onActivityCreated() - onStart() - onResume()     Fragment C is visible
remove Fragment C :     onPause() - onStop() - onDestroyView()                              Activity is visible
(Back button clicked)
Fragment C :        onCreateView() - onActivityCreated() - onStart() - onResume()                   Fragment C is visible
(Back button clicked)
Fragment C :        onPause() - onStop() - onDestroyView() - onDestroy() - onDetach()               
Fragment A :        onCreateView() - onActivityCreated() - onStart() - onResume()                   Fragment A is visible
(Back button clicked)
Fragment A :        onPause() - onStop() - onDestroyView() - onDestroy() - onDetach()               Activity is visible
(Back button clicked)
Activity :      onPause() - onStop() - onDestroy()                              App is closed, nothing is visible

— Javi
स्रोत

1

बहुत हो गया। अच्छा प्रयास!

— पल्प_फिक्शन

तो क्या हम कह सकते हैं कि टुकड़ों के साथ काम करते समय बैक बटन FragmentManager.popBackStack () फ़ंक्शन के समान फैशन में काम करता है?

— टिनटिन

महान जवाब, खिचड़ी भाषा बेहतर हो। इसका उत्तर स्वीकार किया जाना चाहिए।

— शिरीष हेरवाडे

25

के बीच बुनियादी अंतर add()और के replace()रूप में वर्णित किया जा सकता है:

add() बस कुछ मूल तत्व के लिए एक टुकड़ा जोड़ने के लिए प्रयोग किया जाता है।
replace() इसी तरह व्यवहार करता है लेकिन पहले यह पिछले टुकड़े हटाता है और फिर अगला टुकड़ा जोड़ता है।

हम सटीक अंतर तब देख सकते हैं जब हम addToBackStack()साथ add()या साथ में उपयोग करते हैंreplace() ।

जब हम बैक बटन दबाते हैं तो add()... onCreateView को कभी भी कॉल नहीं किया जाता है, लेकिन replace()जब हम बैक बटन दबाते हैं, तो ऑनक्रिएट व्यू को हर बार कॉल किया जाता है।

— Avanindra_dubey
स्रोत

1

तो एंड्रॉइड मेमोरी के मामले में अधिक बोझ है () परिणाम, क्योंकि पिछले टुकड़े का दृश्य नष्ट नहीं हुआ है?

— डेरेकी

@ डेरेकी हां, मुझे ऐसा लगता है।

— अर्पित जे।

मैं क्या देख रहा था

— परवेज़ रफ़ी

2

जब हम पहला फ्रैगमेंट जोड़ते हैं -> दूसरा फ्रैगमेंट ऐड () विधि का उपयोग करते हैं

 btn_one.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Toast.makeText(getActivity(),"Click First 
Fragment",Toast.LENGTH_LONG).show();

                Fragment fragment = new SecondFragment();
                getActivity().getSupportFragmentManager().beginTransaction()
                        .add(R.id.fragment_frame, fragment, fragment.getClass().getSimpleName()).addToBackStack(null).commit();
//                        .replace(R.id.fragment_frame, fragment, fragment.getClass().getSimpleName()).addToBackStack(null).commit();

            }
        });

जब हम खंड में जोड़ () का उपयोग करते हैं

E/Keshav SecondFragment: onAttach
E/Keshav SecondFragment: onCreate
E/Keshav SecondFragment: onCreateView
E/Keshav SecondFragment: onActivityCreated
E/Keshav SecondFragment: onStart
E/Keshav SecondFragment: onResume

जब हम विखंडन में प्रतिस्थापित () का उपयोग करते हैं

पहली - दूसरी विधि में टुकड़े करने के लिए पहली जगह जा रहा है - दूसरा () विधि का उपयोग कर

 btn_one.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Toast.makeText(getActivity(),"Click First Fragment",Toast.LENGTH_LONG).show();

                Fragment fragment = new SecondFragment();
                getActivity().getSupportFragmentManager().beginTransaction()
//                        .add(R.id.fragment_frame, fragment, fragment.getClass().getSimpleName()).addToBackStack(null).commit();
                        .replace(R.id.fragment_frame, fragment, fragment.getClass().getSimpleName()).addToBackStack(null).commit();

            }
        });

E/Keshav SecondFragment: onAttach
E/Keshav SecondFragment: onCreate

E/Keshav FirstFragment: onPause -------------------------- FirstFragment
E/Keshav FirstFragment: onStop --------------------------- FirstFragment
E/Keshav FirstFragment: onDestroyView -------------------- FirstFragment

E/Keshav SecondFragment: onCreateView
E/Keshav SecondFragment: onActivityCreated
E/Keshav SecondFragment: onStart
E/Keshav SecondFragment: onResume

रिप्लेसमेंट फर्स्ट फ्रैगमेंट के मामले में ये तरीका अतिरिक्त है (onPause, onStop, onDestroyView अतिरिक्त कहा जाता है)

ई / केशव फर्स्टफ्रैगमेंट: ऑनपॉज

ई / केशव FirstFragment: onStop

ई / केशव FirstFragment: onDestroyView

— केशव गेरा
स्रोत

0

FragmentManger के फ़ंक्शन को जोड़ने और बदलने को इन 1. के रूप में वर्णित किया जा सकता है। इसका मतलब है कि यह टुकड़ा बैक स्टैक में टुकड़े को जोड़ देगा और यह दिए गए फ्रेम पर दिखाई देगा जैसा आप प्रदान कर रहे हैं

getFragmentManager.beginTransaction.add(R.id.contentframe,Fragment1.newInstance(),null)

2.replace का अर्थ है कि आप दिए गए फ्रेम में एक और टुकड़े के साथ टुकड़े की जगह ले रहे हैं

getFragmentManager.beginTransaction.replace(R.id.contentframe,Fragment1.newInstance(),null)

दोनों के बीच मुख्य उपयोगिता यह है कि जब आप वापस स्टैकिंग कर रहे हैं, तो खंड को ताज़ा किया जाएगा, लेकिन जोड़ पिछले टुकड़े को ताज़ा नहीं करेगा।

— राज कावड़िया
स्रोत

0

ध्यान देने योग्य बात:

बैकस्ट के साथ रिप्लेस और रिप्लेस के बीच का अंतर तब होता है जब हम केवल रिप्लेस का उपयोग करते हैं तब टुकड़ा नष्ट हो जाता है (ondestroy () कहा जाता है) और जब हम बैकस्ट के साथ रिप्लेस का उपयोग करते हैं तब ऑनडेस्ट्रो () का टुकड़ा नहीं कहा जाता है (जब बैक बटन दबाया जाता है तब टुकड़े को आमंत्रित किया जाता है) onCreateView () के साथ

— लॉयड डिकोस्टा
स्रोत

0

यहाँ एक तस्वीर है जो add()और के बीच के अंतर को दिखाती हैreplace()

इसलिए add()विधि FragmentContainer में पिछले टुकड़े के शीर्ष पर टुकड़े जोड़ती रहती है ।

जबकि replace()विधियाँ कंटेनरों से पिछले सभी फ्रैग्मेंट को साफ़ करती हैं और फिर इसे फ्रैगमेंटकंटेनर में जोड़ देती हैं।

AddToBackStack क्या है

addtoBackStackमेथड को ऐड () और रिप्लेस मेथड्स के साथ प्रयोग किया जा सकता है। यह Fragment API में एक अलग उद्देश्य प्रदान करता है।

उद्देश्य क्या है?

गतिविधि एपीआई के विपरीत फ्रैगमेंट एपीआई डिफ़ॉल्ट रूप से बैक बटन नेविगेशन के साथ नहीं आता है । अगर आप पिछले Fragment में वापस जाना चाहते हैं तो हम Fragment में addToBackStack () मेथड का इस्तेमाल करते हैं। आइए दोनों को समझें

मामला एक:

getSupportFragmentManager()
            .beginTransaction()
            .add(R.id.fragmentContainer, fragment, "TAG")
            .addToBackStack("TAG")
            .commit();

केस 2:

getSupportFragmentManager()
            .beginTransaction()
            .add(R.id.fragmentContainer, fragment, "TAG")
            .commit();

— रोहित सिंह
स्रोत