RecyclerView Adapter Data कैसे अपडेट करें?


274

यह पता लगाने की कोशिश कर रहा है कि RecyclerViewएडेप्टर को अपडेट करने में क्या समस्या है ।

उत्पादों की एक नई सूची प्राप्त करने के बाद, मैंने कोशिश की:

  1. ArrayListउस खंड से अपडेट करें जहां recyclerViewबनाया गया है, एडॉप्टर पर नया डेटा सेट करें, फिर कॉल करें adapter.notifyDataSetChanged(); काम नहीं किया।

  2. एक नया एडेप्टर बनाएँ, जैसा कि अन्य लोगों ने किया, और इसने उनके लिए काम किया, लेकिन मेरे लिए कोई बदलाव नहीं: recyclerView.setAdapter(new RecyclerViewAdapter(newArrayList))

  3. एक विधि बनाएं Adapterजिसमें डेटा को निम्नानुसार अपडेट किया जाए:

    public void updateData(ArrayList<ViewModel> viewModels) {
       items.clear();
       items.addAll(viewModels);
       notifyDataSetChanged();
    }
    

    फिर जब भी मैं डेटा सूची को अपडेट करना चाहता हूं तो मैं इस विधि को कॉल करता हूं; काम नहीं किया।

  4. यह जांचने के लिए कि क्या मैं किसी भी तरह से recyclerView को संशोधित कर सकता हूं, और मैंने कम से कम एक आइटम को हटाने की कोशिश की:

     public void removeItem(int position) {
        items.remove(position);
        notifyItemRemoved(position);
    }
    

    सब कुछ वैसा का वैसा ही रहा।

यहाँ मेरा एडाप्टर है:

public class RecyclerViewAdapter extends RecyclerView.Adapter<RecyclerViewAdapter.ViewHolder> implements View.OnClickListener {

    private ArrayList<ViewModel> items;
    private OnItemClickListener onItemClickListener;

    public RecyclerViewAdapter(ArrayList<ViewModel> items) {
        this.items = items;
    }


    public void setOnItemClickListener(OnItemClickListener onItemClickListener) {
        this.onItemClickListener = onItemClickListener;
    }

    @Override
    public ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
        View v = LayoutInflater.from(parent.getContext()).inflate(R.layout.item_recycler, parent, false);
        v.setOnClickListener(this);
        return new ViewHolder(v);
    }

    public void updateData(ArrayList<ViewModel> viewModels) {
        items.clear();
        items.addAll(viewModels);
        notifyDataSetChanged();
    }
    public void addItem(int position, ViewModel viewModel) {
        items.add(position, viewModel);
        notifyItemInserted(position);
    }

    public void removeItem(int position) {
        items.remove(position);
        notifyItemRemoved(position);
    }



    @Override
    public void onBindViewHolder(ViewHolder holder, int position) {
        ViewModel item = items.get(position);
        holder.title.setText(item.getTitle());
        Picasso.with(holder.image.getContext()).load(item.getImage()).into(holder.image);
        holder.price.setText(item.getPrice());
        holder.credit.setText(item.getCredit());
        holder.description.setText(item.getDescription());

        holder.itemView.setTag(item);
    }

    @Override
    public int getItemCount() {
        return items.size();
    }

    @Override
    public void onClick(final View v) {
        // Give some time to the ripple to finish the effect
        if (onItemClickListener != null) {
            new Handler().postDelayed(new Runnable() {
                @Override
                public void run() {
                    onItemClickListener.onItemClick(v, (ViewModel) v.getTag());
                }
            }, 0);
        }
    }

    protected static class ViewHolder extends RecyclerView.ViewHolder {
        public ImageView image;
        public TextView price, credit, title, description;

        public ViewHolder(View itemView) {
            super(itemView);
            image = (ImageView) itemView.findViewById(R.id.image);
            price = (TextView) itemView.findViewById(R.id.price);
            credit = (TextView) itemView.findViewById(R.id.credit);
            title = (TextView) itemView.findViewById(R.id.title);
            description = (TextView) itemView.findViewById(R.id.description);
        }
    }

    public interface OnItemClickListener {

        void onItemClick(View view, ViewModel viewModel);

    }
}

और मैं RecyclerViewनिम्नानुसार आरंभ करता हूं :

recyclerView = (RecyclerView) view.findViewById(R.id.recycler);
recyclerView.setLayoutManager(new GridLayoutManager(getActivity(), 5));
adapter = new RecyclerViewAdapter(items);
adapter.setOnItemClickListener(this);
recyclerView.setAdapter(adapter);

तो, नए प्राप्त आइटमों को प्रदर्शित करने के लिए मैं वास्तव में एडॉप्टर डेटा को कैसे अपडेट करूं?


अद्यतन: मुद्दा यह था कि लेआउट जहां gridView को देखा गया था:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="match_parent"
    android:tag="catalog_fragment"
    android:layout_height="match_parent">

    <FrameLayout
        android:orientation="vertical"
        android:layout_width="match_parent"
        android:layout_height="match_parent">

        <android.support.v7.widget.RecyclerView
            android:id="@+id/recycler"
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            android:clipToPadding="false"/>

        <ImageButton
            android:id="@+id/fab"
            android:layout_gravity="top|end"
            style="@style/FabStyle"/>

    </FrameLayout>
</LinearLayout>

तब मैंने सिर्फ अभिभावक लेआउट के रूप में हटा दिया LinearLayoutऔर बनाया FrameLayout


items.clear(); items.addAll(newItems);एक बदसूरत पैटर्न है। यदि आपको वास्तव में यहां रक्षात्मक नकल की आवश्यकता है, items = new ArrayList(newItems);तो यह कम बदसूरत होगा।
Miha_x64

2
@ miha-x64 आप सही हैं - यह कम बदसूरत होगा। समस्या यह है कि यह सिर्फ काम नहीं करता है। एडाप्टर को संदर्भ के लिए कोई संदर्भ नहीं मिलता है। इसका संदर्भ खुद ही मिल जाता है। इसलिए यदि आप एक नया डेटासेट बनाते हैं तो इसका एक नया संदर्भ होता है जबकि एडॉप्टर अभी भी केवल पुराने को ही जानता है।
12 जनवरी को अविश्वसनीय जन

जवाबों:


326

मैं RecyclerView के साथ काम कर रहा हूं और दोनों को हटाने और अद्यतन अच्छी तरह से काम करता है।

1) REMOVE: किसी रिसाइक्लर व्यू से किसी आइटम को हटाने के लिए 4 चरण होते हैं

list.remove(position);
recycler.removeViewAt(position);
mAdapter.notifyItemRemoved(position);                 
mAdapter.notifyItemRangeChanged(position, list.size());

कोड की ये लाइन मेरे लिए काम करती है।

2) अद्यतन डेटा: केवल चीजों को मुझे करना है

mAdapter.notifyDataSetChanged();

यह सब आपको Actvity / Fragment कोड में करना होगा, RecyclerView Adapter कोड में नहीं।


2
धन्यवाद। कृपया अद्यतन की जाँच करें। किसी तरह, रेखीय लेआउट RecylerView अद्यतन सूची नहीं होने देता है।
फिलिप्पुस लुचियानेंको

40
आपको केवल इन दो पंक्तियों की आवश्यकता है: list.remove (स्थिति); (स्थिति) mAdapter.notifyItemRemoved;
Feisal

3
मेरे लिए, लाइनें recycler.removeViewAt(position);(या बल्कि recycler.removeAllViews()) महत्वपूर्ण थीं।
MSpeed

2
हटाने के दौरान कष्टप्रद गड़बड़ से बचने के लिए एक महत्वपूर्ण विचार: आपको इस लाइन को recycler.removeViewAt (स्थिति) पर कॉल करने की आवश्यकता नहीं है;
एंजेलो नोडारी

7
NotifyDataSetChanged ओवरकिल है, खासकर यदि आप बहुत लंबी सूचियों के साथ काम कर रहे हैं। कुछ वस्तुओं के लिए पूरी चीज़ को पुनः लोड करें? जी नहीं, धन्यवाद। इसके अलावा, recycler.removeViewAt (स्थिति)? जरूरत नहीं। और "mAdapter.notifyItemRemoved (स्थिति)" और "mAdapter.notifyItemRangeChanged (स्थिति, list.size ())" दोनों को कॉल करने की आवश्यकता नहीं है। कुछ निकालें, या एक निकालें। ONCE को सूचित करें। उनमें से एक को बुलाओ।
विटर ह्यूगो श्वाब

328

यह भविष्य के आगंतुकों के लिए एक सामान्य उत्तर है। एडॉप्टर डेटा को अपडेट करने के विभिन्न तरीके बताए गए हैं। इस प्रक्रिया में हर बार दो मुख्य चरण शामिल हैं:

  1. डेटा सेट अपडेट करें
  2. परिवर्तन के एडाप्टर को सूचित करें

एकल आइटम डालें

सूचकांक में "सुअर" जोड़ें 2

एकल आइटम डालें

String item = "Pig";
int insertIndex = 2;
data.add(insertIndex, item);
adapter.notifyItemInserted(insertIndex);

कई आइटम डालें

इंडेक्स में तीन और जानवर डालें 2

कई आइटम डालें

ArrayList<String> items = new ArrayList<>();
items.add("Pig");
items.add("Chicken");
items.add("Dog");
int insertIndex = 2;
data.addAll(insertIndex, items);
adapter.notifyItemRangeInserted(insertIndex, items.size());

एकल आइटम निकालें

सूची से "सुअर" निकालें।

एकल आइटम निकालें

int removeIndex = 2;
data.remove(removeIndex);
adapter.notifyItemRemoved(removeIndex);

कई आइटम निकालें

"ऊंट" और "भेड़" को सूची से हटा दें।

कई आइटम निकालें

int startIndex = 2; // inclusive
int endIndex = 4;   // exclusive
int count = endIndex - startIndex; // 2 items will be removed
data.subList(startIndex, endIndex).clear();
adapter.notifyItemRangeRemoved(startIndex, count);

सभी आइटम निकालें

पूरी सूची साफ़ करें।

सभी आइटम निकालें

data.clear();
adapter.notifyDataSetChanged();

पुरानी सूची को नई सूची से बदलें

पुरानी सूची को साफ़ करें फिर एक नया जोड़ें।

पुरानी सूची को नई सूची से बदलें

// clear old list
data.clear();

// add new list
ArrayList<String> newList = new ArrayList<>();
newList.add("Lion");
newList.add("Wolf");
newList.add("Bear");
data.addAll(newList);

// notify adapter
adapter.notifyDataSetChanged();

का adapterसंदर्भ है data, इसलिए यह महत्वपूर्ण है कि मैंने dataएक नई वस्तु पर सेट नहीं किया है। इसके बजाय मैंने पुरानी वस्तुओं को साफ किया dataऔर फिर नए जोड़े।

एकल आइटम अद्यतन करें

"भेड़" आइटम बदलें ताकि यह कहे कि "मुझे भेड़ पसंद है।"

एकल आइटम अद्यतन करें

String newValue = "I like sheep.";
int updateIndex = 3;
data.set(updateIndex, newValue);
adapter.notifyItemChanged(updateIndex);

एकल आइटम ले जाएँ

स्थिति से "शिप" ले जाएँ 3स्थिति के लिए 1

एकल आइटम ले जाएँ

int fromPosition = 3;
int toPosition = 1;

// update data array
String item = data.get(fromPosition);
data.remove(fromPosition);
data.add(toPosition, item);

// notify adapter
adapter.notifyItemMoved(fromPosition, toPosition);

कोड

यहाँ आपके संदर्भ के लिए प्रोजेक्ट कोड है। इस उत्तर पर RecyclerView Adapter कोड पाया जा सकता है ।

MainActivity.java

public class MainActivity extends AppCompatActivity implements MyRecyclerViewAdapter.ItemClickListener {

    List<String> data;
    MyRecyclerViewAdapter adapter;

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

        // data to populate the RecyclerView with
        data = new ArrayList<>();
        data.add("Horse");
        data.add("Cow");
        data.add("Camel");
        data.add("Sheep");
        data.add("Goat");

        // set up the RecyclerView
        RecyclerView recyclerView = findViewById(R.id.rvAnimals);
        LinearLayoutManager layoutManager = new LinearLayoutManager(this);
        recyclerView.setLayoutManager(layoutManager);
        DividerItemDecoration dividerItemDecoration = new DividerItemDecoration(recyclerView.getContext(),
                layoutManager.getOrientation());
        recyclerView.addItemDecoration(dividerItemDecoration);
        adapter = new MyRecyclerViewAdapter(this, data);
        adapter.setClickListener(this);
        recyclerView.setAdapter(adapter);
    }

    @Override
    public void onItemClick(View view, int position) {
        Toast.makeText(this, "You clicked " + adapter.getItem(position) + " on row number " + position, Toast.LENGTH_SHORT).show();
    }

    public void onButtonClick(View view) {
        insertSingleItem();
    }

    private void insertSingleItem() {
        String item = "Pig";
        int insertIndex = 2;
        data.add(insertIndex, item);
        adapter.notifyItemInserted(insertIndex);
    }

    private void insertMultipleItems() {
        ArrayList<String> items = new ArrayList<>();
        items.add("Pig");
        items.add("Chicken");
        items.add("Dog");
        int insertIndex = 2;
        data.addAll(insertIndex, items);
        adapter.notifyItemRangeInserted(insertIndex, items.size());
    }

    private void removeSingleItem() {
        int removeIndex = 2;
        data.remove(removeIndex);
        adapter.notifyItemRemoved(removeIndex);
    }

    private void removeMultipleItems() {
        int startIndex = 2; // inclusive
        int endIndex = 4;   // exclusive
        int count = endIndex - startIndex; // 2 items will be removed
        data.subList(startIndex, endIndex).clear();
        adapter.notifyItemRangeRemoved(startIndex, count);
    }

    private void removeAllItems() {
        data.clear();
        adapter.notifyDataSetChanged();
    }

    private void replaceOldListWithNewList() {
        // clear old list
        data.clear();

        // add new list
        ArrayList<String> newList = new ArrayList<>();
        newList.add("Lion");
        newList.add("Wolf");
        newList.add("Bear");
        data.addAll(newList);

        // notify adapter
        adapter.notifyDataSetChanged();
    }

    private void updateSingleItem() {
        String newValue = "I like sheep.";
        int updateIndex = 3;
        data.set(updateIndex, newValue);
        adapter.notifyItemChanged(updateIndex);
    }

    private void moveSingleItem() {
        int fromPosition = 3;
        int toPosition = 1;

        // update data array
        String item = data.get(fromPosition);
        data.remove(fromPosition);
        data.add(toPosition, item);

        // notify adapter
        adapter.notifyItemMoved(fromPosition, toPosition);
    }
}

टिप्पणियाँ

  • यदि आप उपयोग करते हैं notifyDataSetChanged(), तो कोई एनीमेशन नहीं किया जाएगा। यह एक महंगा ऑपरेशन भी हो सकता है, इसलिए इसका उपयोग करने की अनुशंसा नहीं की जाती है notifyDataSetChanged()यदि आप केवल एक आइटम या कई मदों को अपडेट कर रहे हैं।
  • यदि आप सूची में बड़े या जटिल बदलाव कर रहे हैं तो डिफ्यूटिल की जाँच करें ।

आगे के अध्ययन


5
बहुत बढ़िया जवाब! आइटम में प्रतिस्थापित करते समय क्या कदम होंगे, जिसके परिणामस्वरूप एक अलग दृश्य प्रकार होगा? क्या यह सिर्फ नोटिफाई किया गया है या एक सम्मिलित करने के बाद संयुक्त हटा दिया गया है?
सेमाफोर

आपके न्यूनतम उदाहरण के साथ, ऐसा लगता है कि InformItemChanged पर्याप्त है। यह बदले हुए आइटम के लिए onCreateViewHolder और onBindViewHolder को कॉल करेगा और अलग दृश्य दिखाया जाएगा। मुझे एक आइटम को अपडेट करने वाले एप्लिकेशन में एक समस्या थी, जिसके परिणामस्वरूप एक अलग दृश्य होगा, लेकिन एक और समस्या प्रतीत होती है।
Semaphor

@ मेरे प्रश्न के बारे में किसी भी विचार का पता लगाएं: stackoverflow.com/questions/57332222/… मैंने इस धागे में सूचीबद्ध सब कुछ करने की कोशिश की, लेकिन कोई फायदा नहीं हुआ :(

जब हम परिवर्तन करने के लिए डिफुटिल्स का उपयोग करते हैं तो कैसे करें? वे मैन्युअल रूप से कॉल करने जैसा तरल पदार्थ नहीं हैं। <Action> ()।
गुइलहे

1
वास्तव में गेंद को नीचे गिरा दिया Update single item, क्या मुझे कछुए की तरह
ardnew

46

इसी से मेरा काम बना है:

recyclerView.setAdapter(new RecyclerViewAdapter(newList));
recyclerView.invalidate();

एक नया एडेप्टर बनाने के बाद जिसमें अपडेट की गई सूची है (मेरे मामले में यह एक एरेलेलिस्ट में परिवर्तित किया गया डेटाबेस था) और एडेप्टर के रूप में सेट करते हुए, मैंने कोशिश की recyclerView.invalidate()और यह काम कर गया।


12
क्या यह बदले गए आइटम को अपडेट करने के बजाय पूरे दृश्य को ताज़ा नहीं करेगा?
ट्वायलेट

13
हर बार एक नया एडॉप्टर बनाने के बजाय, मैंने जो किया वह था नई सूची को सेट करने के लिए अपने कस्टम एडेप्टर क्लास में एक सेटर विधि बनाना। उसके बाद, बस YourAdapter adapter = (YourAdapter) recyclerView.getAdapter(); adapter.yourSetterMethod(newList); adapter.notifyDataSetChanged();कहा जा रहा है कि कहा जाता है, ऐसा लगता है कि ओपी ने पहले क्या कोशिश की (सिर्फ इस पर टिप्पणी के रूप में जोड़ रहा है ताकि यह किसी और की मदद कर सके, जैसा कि मेरे मामले में काम किया है)।
केविन ली

2
पाठक, इसके लिए समझौता मत करो। यह जवाब काम करता है, लेकिन एक अधिक कुशल तरीका है। सभी डेटा को फिर से लोड करने के बजाय , सबसे कुशल तरीका एडेप्टर में नया डेटा जोड़ना है।
सेबेस्टियलोनो

हां, मैं @TWilly से सहमत हूं, यह UI पर पूरा दृश्य फिर से तैयार करेगा।
राहुल

18

आपके पास ऐसा करने के लिए 2 विकल्प हैं: एडाप्टर से UI को ताज़ा करें:

mAdapter.notifyDataSetChanged();

या इसे स्वयं recyclerView से ताज़ा करें:

recyclerView.invalidate();

15

एक अन्य विकल्प डिफुटिल का उपयोग करना है । यह नई सूची के खिलाफ मूल सूची की तुलना करेगा और यदि कोई बदलाव है तो नई सूची का उपयोग अपडेट के रूप में करेगा।

मूल रूप से, हम पुराने डेटा बनाम नए डेटा की तुलना करने के लिए डिफुटिल का उपयोग कर सकते हैं और इसे अपनी ओर से InformItemRangeRemoved, और InformItemRangeChanged और InformItemRangeInserted कॉल कर सकते हैं।

सूचना का उपयोग करने के बजाय diffUtil का एक त्वरित उदाहरण

DiffResult diffResult = DiffUtil
                .calculateDiff(new MyDiffUtilCB(getItems(), items));

//any clear up on memory here and then
diffResult.dispatchUpdatesTo(this);

//and then, if necessary
items.clear()
items.addAll(newItems)

मैं एक बड़ी सूची के मामले में मुख्य धागा बंद गणना काम करते हैं।


1
हालांकि यह सही है, अपने एडेप्टर के अंदर डेटा को कैसे अपडेट करें? मान लीजिए कि मैं एडॉप्टर में सूची <ऑब्जेक्ट> प्रदर्शित कर रहा हूं और मुझे सूची <ऑब्जेक्ट> के साथ एक नया अपडेट प्राप्त हुआ है। डिफ्यूटिल एक अंतर की गणना करेगा और इसे एडेप्टर में भेज देगा, लेकिन यह आपके मामले में मूल या नई सूची के साथ कुछ नहीं कर रहा है getItems()। आप कैसे जानते हैं कि मूल सूची से कौन से डेटा को हटाने / जोड़ने / अपडेट करने की आवश्यकता है?
वैनोमार्ट

1
शायद यह लेख मदद कर सकता है। .. medium.com/@nullthemall/...
j2emanue

@vanomart आपको केवल अपने स्थानीय सूची क्षेत्र को नई सूची मूल्य के साथ सीधे बदलना होगा जैसा कि आप सामान्य रूप से करते हैं, इस दृष्टिकोण में एकमात्र अंतर यह है कि इसके बजाय InformDataSetChanged () आप व्यू को अपडेट करने के लिए DiffUtil का उपयोग करते हैं।
कैरिज़ो

मेरे बारे में कोई विचार? मैं यहाँ सूचीबद्ध सब कुछ करने की कोशिश की, लेकिन भाग्य नहीं: stackoverflow.com/questions/57332222/…

आपके उत्तर के लिए धन्यवाद! क्या आप समझा सकते हैं कि मुझे डिस्पैचअपडेट्स के बाद "स्पष्ट" और "एडऑल" क्यों डालना चाहिए ?? Tnx!
आदि अजर्य

10

सूची, ग्रिडव्यू और रिसाइकलव्यू का डेटा अपडेट करें

mAdapter.notifyDataSetChanged();

या

mAdapter.notifyItemRangeChanged(0, itemList.size());

जब तक उपयोगकर्ता स्क्रॉल करना शुरू नहीं करता है, तब तक यह मेरे डेटा को अपडेट नहीं करता है। मैंने सभी जगह देखा है और यह पता नहीं लगा सकता कि क्यों ..
SudoPlz

@SudoPlz आप स्क्रॉल का पता लगाने के लिए कस्टम स्क्रॉल श्रोता का उपयोग कर सकते हैं और अपने अधिसूचित ऑपरेशन जैसे stackoverflow.com/a/31174967/4401692
पंकज तलाविया

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

5

वर्तमान डेटा में नए डेटा को जोड़ने का सबसे अच्छा और सबसे अच्छा तरीका है

 ArrayList<String> newItems = new ArrayList<String>();
 newItems = getList();
 int oldListItemscount = alcontainerDetails.size();
 alcontainerDetails.addAll(newItems);           
 recyclerview.getAdapter().notifyItemChanged(oldListItemscount+1, al_containerDetails);

2
मैं लोगों को हर समय "InformDataSetChanged" का उपयोग करते हुए देखता हूं, क्या यह ओवरकिल नहीं है? मेरा मतलब है, पूरी सूची को फिर से लोड करें क्योंकि कुछ बदला गया या जोड़ा गया था ... मुझे यह दृष्टिकोण पसंद है, अभी "InformItemRangeInserted" विधि के साथ लागू हो रहा था।
विटर ह्यूगो श्वाब

5

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

        mAdapter = new ModelAdapter(getContext(),new ArrayList<Model>());
   // then when i get data

        mAdapter.update(response.getModelList());
  //  and update is in my adapter

        public void update(ArrayList<Model> modelList){
            adapterModelList.clear(); 
            for (Product model: modelList) {
                adapterModelList.add(model); 
            }
           mAdapter.notifyDataSetChanged();
        }

बस।


2

ये तरीके एक बुनियादी का उपयोग शुरू करने के लिए कुशल और अच्छे हैं RecyclerView

private List<YourItem> items;

public void setItems(List<YourItem> newItems)
{
    clearItems();
    addItems(newItems);
}

public void addItem(YourItem item, int position)
{
    if (position > items.size()) return;

    items.add(item);
    notifyItemInserted(position);
}

public void addMoreItems(List<YourItem> newItems)
{
    int position = items.size() + 1;
    newItems.addAll(newItems);
    notifyItemChanged(position, newItems);
}

public void addItems(List<YourItem> newItems)
{
    items.addAll(newItems);
    notifyDataSetChanged();
}

public void clearItems()
{
    items.clear();
    notifyDataSetChanged();
}

public void addLoader()
{
    items.add(null);
    notifyItemInserted(items.size() - 1);
}

public void removeLoader()
{
    items.remove(items.size() - 1);
    notifyItemRemoved(items.size());
}

public void removeItem(int position)
{
    if (position >= items.size()) return;

    items.remove(position);
    notifyItemRemoved(position);
}

public void swapItems(int positionA, int positionB)
{
    if (positionA > items.size()) return;
    if (positionB > items.size()) return;

    YourItem firstItem = items.get(positionA);

    videoList.set(positionA, items.get(positionB));
    videoList.set(positionB, firstItem);

    notifyDataSetChanged();
}

आप उन्हें एक एडॉप्टर क्लास के अंदर या अपने फ्रैगमेंट या एक्टिविटी में लागू कर सकते हैं, लेकिन उस स्थिति में आपको नोटिफिकेशन के तरीकों को कॉल करने के लिए एडॉप्टर को इंस्टेंट करना होगा। मेरे मामले में मैं आमतौर पर इसे एडॉप्टर में लागू करता हूं।


2

मुझे पता चला कि RecyclerView को फिर से लोड करने का एक बहुत सरल तरीका सिर्फ कॉल करना है

recyclerView.removeAllViews();

यह पहले RecyclerView की सभी सामग्री को हटा देगा और फिर इसे अद्यतन मूल्यों के साथ फिर से जोड़ देगा।


2
कृपया इसका उपयोग न करें। आप परेशानी पूछ रहे होंगे।
dell116

1

मुझे जवाब लंबे समय के बाद मिला

  SELECTEDROW.add(dt);
                notifyItemInserted(position);
                SELECTEDROW.remove(position);
                notifyItemRemoved(position);

0

यदि उपरोक्त टिप्पणियों में उल्लिखित कुछ भी आपके लिए काम नहीं कर रहा है। इसका मतलब यह हो सकता है कि समस्या कहीं और है।

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

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.