Android
RecyclerView

परिचय

पैरामीटर

टिप्पणियों

dependencies {
    // Match the version of your support library dependency
    compile 'com.android.support:recyclerview-v7:25.3.1'
}

  //it requires compileSdkVersion 25
  compile 'com.android.support:recyclerview-v7:25.2.0'
  compile 'com.android.support:recyclerview-v7:25.1.0'
  compile 'com.android.support:recyclerview-v7:25.0.0'

  //it requires compileSdkVersion 24
  compile 'com.android.support:recyclerview-v7:24.2.1' 
  compile 'com.android.support:recyclerview-v7:24.2.0' 
  compile 'com.android.support:recyclerview-v7:24.1.1'  
  compile 'com.android.support:recyclerview-v7:24.1.0'  

  //it requires compileSdkVersion 23
  compile 'com.android.support:recyclerview-v7:23.4.0'
  compile 'com.android.support:recyclerview-v7:23.3.0'
  compile 'com.android.support:recyclerview-v7:23.2.1'
  compile 'com.android.support:recyclerview-v7:23.2.0'
  compile 'com.android.support:recyclerview-v7:23.1.1'
  compile 'com.android.support:recyclerview-v7:23.1.0'
  compile 'com.android.support:recyclerview-v7:23.0.1'
  compile 'com.android.support:recyclerview-v7:23.0.0'

  //it requires compileSdkVersion 22
  compile 'com.android.support:recyclerview-v7:22.2.1'
  compile 'com.android.support:recyclerview-v7:22.2.0'
  compile 'com.android.support:recyclerview-v7:22.1.1'
  compile 'com.android.support:recyclerview-v7:22.1.0'
  compile 'com.android.support:recyclerview-v7:22.0.0'

  //it requires compileSdkVersion 21
  compile 'com.android.support:recyclerview-v7:21.0.3'
  compile 'com.android.support:recyclerview-v7:21.0.2'
  compile 'com.android.support:recyclerview-v7:21.0.0'

एक RecyclerView जोड़ना

रिमार्क अनुभाग में वर्णित निर्भरता जोड़ें, फिर अपने लेआउट में एक RecyclerView जोड़ें:

<android.support.v7.widget.RecyclerView
    android:id="@+id/my_recycler_view"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"/>

एक बार जब आप अपने लेआउट में RecyclerView विजेट जोड़ लेते हैं, तो ऑब्जेक्ट को हैंडल प्राप्त करें, इसे लेआउट मैनेजर से कनेक्ट करें और प्रदर्शित होने वाले डेटा के लिए एक एडाप्टर संलग्न करें:

mRecyclerView = (RecyclerView) findViewById(R.id.my_recycler_view);

// set a layout manager (LinearLayoutManager in this example)

mLayoutManager = new LinearLayoutManager(getApplicationContext());
mRecyclerView.setLayoutManager(mLayoutManager);

// specify an adapter
mAdapter = new MyAdapter(myDataset);
mRecyclerView.setAdapter(mAdapter);

या बस लाइनों को जोड़ने से xml से लेआउट लेआउट प्रबंधक:

xmlns:app="http://schemas.android.com/apk/res-auto"
app:layoutManager="android.support.v7.widget.LinearLayoutManager"

आप जानते हैं कि की सामग्री में बदलाव तो RecyclerView के लेआउट आकार में परिवर्तन नहीं होगा RecyclerView , घटक के प्रदर्शन में सुधार के लिए निम्न कोड का उपयोग करें। यदि RecyclerView का एक निश्चित आकार है, तो यह जानता है कि RecyclerView अपने बच्चों के कारण खुद को आकार नहीं देगा, इसलिए यह अनुरोध लेआउट को बिल्कुल नहीं कहता है। यह केवल परिवर्तन को संभालता है। यदि अभिभावक, समन्वयक, लेआउट, या जो भी हो, को अमान्य करना। (आप इस विधि का उपयोग LayoutManager और Adapter सेट करने से पहले भी कर सकते हैं):

mRecyclerView.setHasFixedSize(true);

RecyclerView इन अंतर्निहित लेआउट प्रबंधकों को उपयोग करने के लिए प्रदान करता है। इसलिए आप RecyclerView का उपयोग करके एक सूची, एक ग्रिड और एक कंपित ग्रिड बना सकते हैं:

1. LinearLayoutManager ऊर्ध्वाधर या क्षैतिज स्क्रॉलिंग सूची में आइटम दिखाता है।
2. GridLayoutManager एक ग्रिड में आइटम दिखाता है।
3. StaggeredGridLayoutManager एक कंपित ग्रिड में आइटम दिखाता है।

वस्तुओं की चिकनी लोडिंग

यदि आपके RecyclerView में आइटम नेटवर्क (आमतौर पर छवियों) से डेटा लोड करते हैं या अन्य प्रसंस्करण करते हैं, तो यह महत्वपूर्ण समय ले सकता है और आप स्क्रीन पर आइटम के साथ समाप्त हो सकते हैं लेकिन पूरी तरह से लोड नहीं किया जा सकता है। इससे बचने के लिए आप मौजूदा LinearLayoutManager को स्क्रीन पर दिखाई देने से पहले कई आइटम को प्रीलोड करने के लिए बढ़ा सकते हैं:

package com.example;

import android.content.Context;
import android.support.v7.widget.LinearLayoutManager;
import android.support.v7.widget.OrientationHelper;
import android.support.v7.widget.RecyclerView;

/**
 * A LinearLayoutManager that preloads items off-screen.
 * <p>
 * Preloading is useful in situations where items might take some time to load
 * fully, commonly because they have maps, images or other items that require
 * network requests to complete before they can be displayed.
 * <p>
 * By default, this layout will load a single additional page's worth of items,
 * a page being a pixel measure equivalent to the on-screen size of the
 * recycler view.  This can be altered using the relevant constructor, or
 * through the {@link #setPages(int)} method.
 */
public class PreLoadingLinearLayoutManager extends LinearLayoutManager {
  private int mPages = 1;
  private OrientationHelper mOrientationHelper;

  public PreLoadingLinearLayoutManager(final Context context) {
    super(context);
  }

  public PreLoadingLinearLayoutManager(final Context context, final int pages) {
    super(context);
    this.mPages = pages;
  }

  public PreLoadingLinearLayoutManager(final Context context, final int orientation, final boolean reverseLayout) {
    super(context, orientation, reverseLayout);
  }

  @Override
  public void setOrientation(final int orientation) {
    super.setOrientation(orientation);
    mOrientationHelper = null;
  }

  /**
   * Set the number of pages of layout that will be preloaded off-screen,
   * a page being a pixel measure equivalent to the on-screen size of the
   * recycler view.
   * @param pages the number of pages; can be {@code 0} to disable preloading
   */
  public void setPages(final int pages) {
    this.mPages = pages;
  }

  @Override
  protected int getExtraLayoutSpace(final RecyclerView.State state) {
    if (mOrientationHelper == null) {
      mOrientationHelper = OrientationHelper.createOrientationHelper(this, getOrientation());
    }
    return mOrientationHelper.getTotalSpace() * mPages;
  }
}

खींचें और छोड़ें और RecyclerView के साथ स्वाइप करें

आप 3rd पार्टी लाइब्रेरीज़ का उपयोग किए बिना RecyclerView के साथ स्वाइप-टू-आउट-एंड-एंड-एंड-ड्रॉप सुविधाओं को लागू कर सकते हैं।
बस ItemTouchHelper समर्थन पुस्तकालय में शामिल ItemTouchHelper वर्ग का उपयोग करें।

SimpleCallback कॉलबैक के साथ ItemTouchHelper को इंस्टेंट करें और जिस कार्यक्षमता का आप समर्थन करते हैं, उसके आधार पर आपको onMove(RecyclerView, ViewHolder, ViewHolder) और / या onSwiped(ViewHolder, int) को ओवरराइड करना चाहिए और अंत में अपने RecyclerView को संलग्न करना चाहिए।

ItemTouchHelper.SimpleCallback simpleItemTouchCallback = new ItemTouchHelper.SimpleCallback(0, ItemTouchHelper.LEFT | ItemTouchHelper.RIGHT) {

    @Override
    public void onSwiped(RecyclerView.ViewHolder viewHolder, int swipeDir) {
        // remove item from adapter
    }

    @Override
    public boolean onMove(RecyclerView recyclerView, RecyclerView.ViewHolder viewHolder, RecyclerView.ViewHolder target) {
            final int fromPos = viewHolder.getAdapterPosition();
            final int toPos = target.getAdapterPosition();
            // move item in `fromPos` to `toPos` in adapter.
            return true;// true if moved, false otherwise
        }
    
};

ItemTouchHelper itemTouchHelper = new ItemTouchHelper(simpleItemTouchCallback);
itemTouchHelper.attachToRecyclerView(recyclerView);

यह ध्यान देने योग्य है कि SimpleCallback निर्माता RecyclerView सभी आइटमों पर समान स्वाइपिंग रणनीति लागू करता है। किसी भी मामले में यह संभव है कि केवल विशिष्ट विधि getSwipeDirs(RecyclerView, ViewHolder) द्वारा विशिष्ट वस्तुओं के लिए डिफ़ॉल्ट स्वाइपिंग दिशा को अद्यतन किया जाए।

उदाहरण के लिए मान लें कि हमारे RecyclerView में एक HeaderViewHolder शामिल है और हम स्पष्ट रूप से इसमें स्वाइप करना नहीं चाहते हैं। यह getSwipeDirs को ओवरराइड करने के लिए पर्याप्त होगा:

@Override
public int getSwipeDirs(RecyclerView recyclerView, RecyclerView.ViewHolder viewHolder) {
    if (viewHolder instanceof HeaderViewHolder) {
        // no swipe for header
        return 0;
    }
    // default swipe for all other items
    return super.getSwipeDirs(recyclerView, viewHolder);
} 

शीर्ष लेख / पाद लेख को RecyclerView में जोड़ें

यह एक नमूना एडॉप्टर कोड है।

public class SampleAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolder> {

private static final int FOOTER_VIEW = 1;

// Define a view holder for Footer view

public class FooterViewHolder extends ViewHolder {
    public FooterViewHolder(View itemView) {
        super(itemView);
        itemView.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                // Do whatever you want on clicking the item
            }
        });
    }
}

// Now define the viewholder for Normal list item
public class NormalViewHolder extends ViewHolder {
    public NormalViewHolder(View itemView) {
        super(itemView);

        itemView.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                // Do whatever you want on clicking the normal items 
            }
        });
    }
}

// And now in onCreateViewHolder you have to pass the correct view
// while populating the list item.

@Override
public RecyclerView.ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {

    View v;

    if (viewType == FOOTER_VIEW) {
        v = LayoutInflater.from(parent.getContext()).inflate(R.layout.list_item_footer, parent, false);

        FooterViewHolder vh = new FooterViewHolder(v);

        return vh;
    }

    v = LayoutInflater.from(parent.getContext()).inflate(R.layout.list_item_normal, parent, false);

    NormalViewHolder vh = new NormalViewHolder(v);

    return vh;
}

// Now bind the viewholders in onBindViewHolder
@Override
public void onBindViewHolder(RecyclerView.ViewHolder holder, int position) {

    try {
        if (holder instanceof NormalViewHolder) {
            NormalViewHolder vh = (NormalViewHolder) holder;

            vh.bindView(position);
        } else if (holder instanceof FooterViewHolder) {
            FooterViewHolder vh = (FooterViewHolder) holder;
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

// Now the critical part. You have return the exact item count of your list
// I've only one footer. So I returned data.size() + 1
// If you've multiple headers and footers, you've to return total count
// like, headers.size() + data.size() + footers.size()

@Override
public int getItemCount() {
    if (data == null) {
        return 0;
    }

    if (data.size() == 0) {
        //Return 1 here to show nothing
        return 1;
    }

    // Add extra view to show the footer view
    return data.size() + 1;
}

// Now define getItemViewType of your own. 

@Override
public int getItemViewType(int position) {
    if (position == data.size()) {
        // This is where we'll add footer.
        return FOOTER_VIEW;
    }

    return super.getItemViewType(position);
}

// So you're done with adding a footer and its action on onClick. 
// Now set the default ViewHolder for NormalViewHolder

public class ViewHolder extends RecyclerView.ViewHolder {
    // Define elements of a row here
    public ViewHolder(View itemView) {
        super(itemView);
        // Find view by ID and initialize here
    }

    public void bindView(int position) {
        // bindView() method to implement actions
    }
}
}

यहाँ हेडर और फुटर के साथ RecyclerView के कार्यान्वयन के बारे में एक अच्छा पढ़ा है ।

वैकल्पिक विधि:

जबकि उपरोक्त उत्तर काम करेगा आप इस दृष्टिकोण का उपयोग कर सकते हैं और साथ ही एक NestedScrollView का उपयोग करके एक NestedScrollView दृश्य का उपयोग कर सकते हैं। आप निम्नलिखित दृष्टिकोण का उपयोग करके हेडर के लिए एक लेआउट जोड़ सकते हैं:

<android.support.v4.widget.NestedScrollView
        android:layout_width="match_parent"
        android:layout_height="match_parent">

     <RelativeLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent">

        <include
            layout="@layout/drawer_view_header"
            android:id="@+id/navigation_header"/>

        <android.support.v7.widget.RecyclerView
            android:layout_below="@id/navigation_header"
            android:id="@+id/followers_list"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"/>

    </RelativeLayout>
</android.support.v4.widget.NestedScrollView>

या आप अपने NestedScrollView में वर्टिकल अलाइनमेंट के साथ एक LinearLayout उपयोग भी कर सकते हैं।

नोट: यह केवल 23.2.0 से ऊपर के RecyclerView साथ काम करेगा

compile 'com.android.support:recyclerview-v7:23.2.0'

ItemViewType के साथ कई ViewHolders का उपयोग करना

कभी-कभी एक RecyclerView को UI में दर्शाई गई सूची में प्रदर्शित होने के लिए कई प्रकार के दृश्यों का उपयोग करने की आवश्यकता होगी, और प्रत्येक दृश्य को फुलाए जाने के लिए एक अलग लेआउट xml की आवश्यकता होती है।

इस समस्या के लिए, आप RecyclerView - getItemViewType(int position) में एक विशेष विधि का उपयोग करके एकल एडेप्टर में विभिन्न व्यूहोल्डर्स का उपयोग कर सकते हैं।

नीचे दो ViewHolders का उपयोग करने का उदाहरण है:

1. सूची प्रविष्टियों को प्रदर्शित करने के लिए एक ViewHolder

2. कई हेडर दृश्य प्रदर्शित करने के लिए एक ViewHolder

   @Override
   public RecyclerView.ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
       View itemView = LayoutInflater.from(context).inflate(viewType, parent, false);
       return ViewHolder.create(itemView, viewType);
   }
   
   @Override
   public void onBindViewHolder(RecyclerView.ViewHolder holder, int position) {
       final Item model = this.items.get(position);
       ((ViewHolder) holder).bind(model);
   }
   
   @Override
   public int getItemViewType(int position) {
       return inSearchState ? R.layout.item_header : R.layout.item_entry;
   }
   
   abstract class ViewHolder {
       abstract void bind(Item model);
   
       public static ViewHolder create(View v, int viewType) {
           return viewType == R.layout.item_header ? new HeaderViewHolder(v) :new EntryViewHolder(v);
       }
   }  
   
   static class EntryViewHolder extends ViewHolder {
       private View v;
   
       public EntryViewHolder(View v) {
           this.v = v;
       }
   
       @Override public void bind(Item model) {
           // Bind item data to entry view.
       }
   }
   
   static class HeaderViewHolder extends ViewHolder {
       private View v;
   
       public HeaderViewHolder(View v) {
           this.v = v;
       }
   
       @Override public void bind(Item model) {
           // Bind item data to header view.
       }
   }
   

किसी खोज दृश्य के साथ RecyclerView के अंदर आइटम फ़िल्टर करें

RecyclerView.Adapter में filter विधि जोड़ें:

public void filter(String text) {
        if(text.isEmpty()){
            items.clear();
            items.addAll(itemsCopy);
        } else{
            ArrayList<PhoneBookItem> result = new ArrayList<>();
            text = text.toLowerCase();
            for(PhoneBookItem item: itemsCopy){
                //match by name or phone
                if(item.name.toLowerCase().contains(text) || item.phone.toLowerCase().contains(text)){
                    result.add(item);
                }
            }
            items.clear();
            items.addAll(result);
        }
        notifyDataSetChanged();
    }

itemsCopy को एडेप्टर के कंस्ट्रक्टर में itemsCopy.addAll(items) तरह इनिशियलाइज़ किया जाता है।

यदि आप ऐसा करते हैं, तो बस फोन filter से OnQueryTextListener से SearchView :

searchView.setOnQueryTextListener(new SearchView.OnQueryTextListener() {
    @Override
    public boolean onQueryTextSubmit(String query) {
        adapter.filter(query);
        return true;
    }

    @Override
    public boolean onQueryTextChange(String newText) {
        adapter.filter(newText);
        return true;
    }
});

RecyclerView के साथ पॉपअप मेनू

इस कोड को अपने ViewHolder के अंदर रखें

नोट: इस कोड में मैं btnExpand क्लिक-इवेंट का उपयोग कर रहा हूँ, पूरे recyclerview क्लिक इवेंट के लिए आप श्रोता को itemView ऑब्जेक्ट पर सेट कर सकते हैं।

public class MyViewHolder extends RecyclerView.ViewHolder{
        CardView cv;
        TextView recordName, visibleFile, date, time;
        Button btnIn, btnExpand;

        public MyViewHolder(final View itemView) {
            super(itemView);

            cv = (CardView)itemView.findViewById(R.id.cardview);
            recordName = (TextView)itemView.findViewById(R.id.tv_record);
            visibleFile = (TextView)itemView.findViewById(R.id.visible_file);
            date = (TextView)itemView.findViewById(R.id.date);
            time = (TextView)itemView.findViewById(R.id.time);
            btnIn = (Button)itemView.findViewById(R.id.btn_in_out);

            btnExpand = (Button) itemView.findViewById(R.id.btn_expand);

            btnExpand.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    PopupMenu popup = new PopupMenu(btnExpand.getContext(), itemView);

                    popup.setOnMenuItemClickListener(new PopupMenu.OnMenuItemClickListener() {
                        @Override
                        public boolean onMenuItemClick(MenuItem item) {
                            switch (item.getItemId()) {
                                case R.id.action_delete:
                                    moveFile(recordName.getText().toString(), getAdapterPosition());
                                    return true;
                                case R.id.action_play:
                                    String valueOfPath = recordName.getText().toString();
                                    Intent intent = new Intent();
                                    intent.setAction(android.content.Intent.ACTION_VIEW);
                                    File file = new File(valueOfPath);
                                    intent.setDataAndType(Uri.fromFile(file), "audio/*");
                                    context.startActivity(intent);
                                    return true;
                                case R.id.action_share:
                                    String valueOfPath = recordName.getText().toString();
                                    File filee = new File(valueOfPath);
                                    try {
                                        Intent sendIntent = new Intent();
                                        sendIntent.setAction(Intent.ACTION_SEND);
                                        sendIntent.setType("audio/*");
                                        sendIntent.putExtra(Intent.EXTRA_STREAM, Uri.fromFile(filee));
                                        context.startActivity(sendIntent);
                                    } catch (NoSuchMethodError | IllegalArgumentException | NullPointerException e) {
                                        e.printStackTrace();
                                    } catch (Exception e) {
                                        e.printStackTrace();
                                    }
                                    return true;
                                default:
                                    return false;
                            }
                        }
                    });
                    // here you can inflate your menu
                    popup.inflate(R.menu.my_menu_item);
                    popup.setGravity(Gravity.RIGHT);

                    // if you want icon with menu items then write this try-catch block.
                    try {
                        Field mFieldPopup=popup.getClass().getDeclaredField("mPopup");
                        mFieldPopup.setAccessible(true);
                        MenuPopupHelper mPopup = (MenuPopupHelper) mFieldPopup.get(popup);
                        mPopup.setForceShowIcon(true);
                    } catch (Exception e) {

                    }
                    popup.show();
                }
            });

        }
    }

मेनू में आइकन दिखाने का वैकल्पिक तरीका

try {
    Field[] fields = popup.getClass().getDeclaredFields();
    for (Field field : fields) {
        if ("mPopup".equals(field.getName())) {
            field.setAccessible(true);
            Object menuPopupHelper = field.get(popup);
            Class<?> classPopupHelper = Class.forName(menuPopupHelper
                .getClass().getName());
            Method setForceIcons = classPopupHelper.getMethod(
                "setForceShowIcon", boolean.class);
            setForceIcons.invoke(menuPopupHelper, true);
            break;
        }
    }
} catch (Exception e) {

}

यहाँ उत्पादन है:

चेतन डेटा परिवर्तन

RecyclerView एक प्रासंगिक एनीमेशन यदि "सूचित" से किसी भी विधि को छोड़कर इस्तेमाल कर रहे हैं प्रदर्शन करेंगे notifyDataSetChanged ; इसमें notifyItemChanged , notifyItemInserted , notifyItemMoved , notifyItemRemoved , आदि शामिल हैं।

एडेप्टर को RecyclerView.Adapter जगह इस क्लास का विस्तार करना चाहिए।

import android.support.annotation.NonNull;
import android.support.v7.widget.RecyclerView;

import java.util.List;

public abstract class AnimatedRecyclerAdapter<T, VH extends RecyclerView.ViewHolder>
        extends RecyclerView.Adapter<VH> {
    protected List<T> models;
            
    protected AnimatedRecyclerAdapter(@NonNull List<T> models) {
        this.models = models;
    }

    //Set new models.
    public void setModels(@NonNull final List<T> models) {
        applyAndAnimateRemovals(models);
        applyAndAnimateAdditions(models);
        applyAndAnimateMovedItems(models);
    }

    //Remove an item at position and notify changes.
    private T removeItem(int position) {
        final T model = models.remove(position);
        notifyItemRemoved(position);
        return model;
    }

    //Add an item at position and notify changes.
    private void addItem(int position, T model) {
        models.add(position, model);
        notifyItemInserted(position);
    }

    //Move an item at fromPosition to toPosition and notify changes.
    private void moveItem(int fromPosition, int toPosition) {
        final T model = models.remove(fromPosition);
        models.add(toPosition, model);
        notifyItemMoved(fromPosition, toPosition);
    }

    //Remove items that no longer exist in the new models.
    private void applyAndAnimateRemovals(@NonNull final List<T> newTs) {
        for (int i = models.size() - 1; i >= 0; i--) {
            final T model = models.get(i);
            if (!newTs.contains(model)) {
                removeItem(i);
            }
        }
    }

    //Add items that do not exist in the old models.
    private void applyAndAnimateAdditions(@NonNull final List<T> newTs) {
        for (int i = 0, count = newTs.size(); i < count; i++) {
            final T model = newTs.get(i);
            if (!models.contains(model)) {
                addItem(i, model);
            }
        }
    }

    //Move items that have changed their position.
    private void applyAndAnimateMovedItems(@NonNull final List<T> newTs) {
        for (int toPosition = newTs.size() - 1; toPosition >= 0; toPosition--) {
            final T model = newTs.get(toPosition);
            final int fromPosition = models.indexOf(model);
            if (fromPosition >= 0 && fromPosition != toPosition) {
                moveItem(fromPosition, toPosition);
            }
        }
    }
}

आपको एडॉप्टर में setModels और List लिए एक ही List उपयोग नहीं करना चाहिए।

आप models को वैश्विक चर घोषित करते models । DataModel केवल एक डमी क्लास है।

private List<DataModel> models;
private YourAdapter adapter;

शुरुआती models को एडॉप्टर से पास करें। YourAdapter AnimatedRecyclerAdapter का कार्यान्वयन है।

models = new ArrayList<>();
//Add models
models.add(new DataModel());
//Do NOT pass the models directly. Otherwise, when you modify global models, 
//you will also modify models in adapter.
//adapter = new YourAdapter(models); <- This is wrong.
adapter = new YourAdapter(new ArrayList(models));

अपने वैश्विक models को अपडेट करने के बाद इसे कॉल करें।

adapter.setModels(new ArrayList(models));

यदि आप equals नहीं करते हैं, तो सभी तुलना संदर्भ द्वारा की जाती है।

SortedList का उपयोग कर उदाहरण

RecyclerView शुरू होने के तुरंत बाद Android ने SortedList वर्ग की शुरुआत की। यह वर्ग उचित एनीमेशन सुनिश्चित करने के लिए RecyclerView.Adapter लिए सभी 'सूचित' विधि कॉल को संभालता है, और यहां तक कि कई परिवर्तनों को बैचने की अनुमति देता है, इसलिए एनिमेशन घबराना नहीं चाहिए।

import android.support.v7.util.SortedList;
import android.support.v7.widget.RecyclerView;
import android.support.v7.widget.util.SortedListAdapterCallback;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;

import java.util.List;

public class MyAdapter extends RecyclerView.Adapter<MyAdapter.ViewHolder> {

    private SortedList<DataModel> mSortedList;

    class ViewHolder extends RecyclerView.ViewHolder {

        TextView text;
        CheckBox checkBox;

        ViewHolder(View itemView){
            super(itemView);

            //Initiate your code here...

        }

        void setDataModel(DataModel model) {
            //Update your UI with the data model passed here...
            text.setText(modle.getText());
            checkBox.setChecked(model.isChecked());
        }
    }

    public MyAdapter() {
        mSortedList = new SortedList<>(DataModel.class, new SortedListAdapterCallback<DataModel>(this) {
            @Override
            public int compare(DataModel o1, DataModel o2) {
                //This gets called to find the ordering between objects in the array.
                if (o1.someValue() < o2.someValue()) {
                    return -1;
                } else if (o1.someValue() > o2.someValue()) {
                    return 1;
                } else {
                    return 0;
                }
            }

            @Override
            public boolean areContentsTheSame(DataModel oldItem, DataModel newItem) {
                //This is to see of the content of this object has changed. These items are only considered equal if areItemsTheSame() returned true.

                //If this returns false, onBindViewHolder() is called with the holder containing the item, and the item's position.
                return oldItem.getText().equals(newItem.getText()) && oldItem.isChecked() == newItem.isChecked();
            }

            @Override
            public boolean areItemsTheSame(DataModel item1, DataModel item2) {
                //Checks to see if these two items are the same. If not, it is added to the list, otherwise, check if content has changed.
                return item1.equals(item2);
            }
        });
    }

    @Override
    public ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
        View itemView = //Initiate your item view here.
        return new ViewHolder(itemView);
    }

    @Override
    public void onBindViewHolder(ViewHolder holder, int position) {
        //Just update the holder with the object in the sorted list from the given position
        DataModel model = mSortedList.get(position);
        if (model != null) {
            holder.setDataModel(model);
        }
    }

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

    public void resetList(List<DataModel> models) {
        //If you are performing multiple changes, use the batching methods to ensure proper animation.
        mSortedList.beginBatchedUpdates();
        mSortedList.clear();
        mSortedList.addAll(models);
        mSortedList.endBatchedUpdates();
    }

    //The following methods each modify the data set and automatically handles calling the appropriate 'notify' method on the adapter.
    public void addModel(DataModel model) {
        mSortedList.add(model);
    }

    public void addModels(List<DataModel> models) {
        mSortedList.addAll(models);
    }

    public void clear() {
        mSortedList.clear();
    }

    public void removeModel(DataModel model) {
        mSortedList.remove(model);
    }

    public void removeModelAt(int i) {
        mSortedList.removeItemAt(i);
    }
}

DataBinding के साथ RecyclerView

यहाँ एक सामान्य ViewHolder वर्ग है जिसे आप किसी भी DataBinding लेआउट के साथ उपयोग कर सकते हैं। यहाँ विशेष रूप से ViewDataBinding वर्ग का एक उदाहरण फुलाया हुआ View ऑब्जेक्ट और DataBindingUtil उपयोगिता वर्ग का उपयोग करके बनाया गया है।

import android.databinding.DataBindingUtil;
import android.support.v7.widget.RecyclerView;
import android.view.View;

public class BindingViewHolder<T> extends RecyclerView.ViewHolder{

    private final T binding;

    public BindingViewHolder(View itemView) {
        super(itemView);
        binding = (T)DataBindingUtil.bind(itemView);
    }

    public T getBinding() {
        return binding;
    }
}

इस वर्ग को बनाने के बाद आप अपनी लेआउट फ़ाइल में <layout> उपयोग इस तरह से उस लेआउट के लिए डेटाबाइंडिंग को सक्षम करने के लिए कर सकते हैं:

file name: my_item.xml

<?xml version="1.0" encoding="utf-8"?>
<layout xmlns:android="http://schemas.android.com/apk/res/android">

    <data>
        <variable
            name="item"
            type="ItemModel" />
    </data>

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent">

        <TextView
            android:layout_width="wrap_content"
            android:layout_height="match_parent"
            android:text="@{item.itemLabel}" />
    </LinearLayout>
</layout>

और यहाँ आपका नमूना डेटा है:

public class ItemModel {
    public String itemLabel;
}

डिफ़ॉल्ट रूप से, Android डेटा बाइंडिंग लाइब्रेरी लेआउट फ़ाइल नाम के आधार पर एक ViewDataBinding वर्ग उत्पन्न करता है, इसे पास्कल मामले में परिवर्तित करता है और इसे "बाइंडिंग" प्रत्यय देता है। इस उदाहरण के लिए यह किया जाएगा MyItemBinding लेआउट फ़ाइल के लिए my_item.xml । उस बाइंडिंग क्लास में लेआउट फ़ाइल में डेटा के रूप में परिभाषित ऑब्जेक्ट को सेट करने के लिए एक सेटर विधि भी होगी (इस उदाहरण के लिए ItemModel )।

अब जब हमारे पास सभी टुकड़े हैं तो हम अपने एडॉप्टर को इस तरह से लागू कर सकते हैं:

class MyAdapter extends RecyclerView.Adapter<BindingViewHolder<MyItemBinding>>{
    ArrayList<ItemModel> items = new ArrayList<>();
        
    public MyAdapter(ArrayList<ItemModel> items) {
        this.items = items;
    }

    @Override public BindingViewHolder<MyItemBinding> onCreateViewHolder(ViewGroup parent, int viewType) {
        return new BindingViewHolder<>(LayoutInflater.from(parent.getContext()).inflate(R.layout.my_item, parent, false));
    }

    @Override public void onBindViewHolder(BindingViewHolder<ItemModel> holder, int position) {
        holder.getBinding().setItemModel(items.get(position));
        holder.getBinding().executePendingBindings();
    }

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

रीसायकल में अंतहीन स्क्रॉलिंग।

यहाँ मैंने रीसायकल व्यू में अंतहीन स्क्रॉलिंग को लागू करने के लिए एक कोड स्निपेट साझा किया है।

चरण 1: पहले रीसायकलव्यू एडॉप्टर में नीचे की तरह एक अमूर्त विधि करें।

public abstract class ViewAllCategoryAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolder> {
    public abstract void load();
}

चरण 2: अब onBindViewHolder और getItemCount() ViewAllCategoryAdapter क्लास और कॉल Load() विधि को नीचे की तरह ओवरराइड करें।

@Override
public void onBindViewHolder(RecyclerView.ViewHolder holder, final int position) {
    if ((position >= getItemCount() - 1)) {
        load();
    }
}

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

चरण 3: अब हर बैकएंड लॉजिक पूरा हो गया है अब इस लॉजिक को निष्पादित करने का समय आ गया है। यह सरल है कि आप लोड विधि को ओवरराइड कर सकते हैं जहां आप अपने एडेप्टर का ऑब्जेक्ट बनाते हैं। उपयोगकर्ता लिस्टिंग के अंत में पहुंचते समय स्वचालित रूप से कॉल करता है।

  adapter = new ViewAllCategoryAdapter(CONTEXT, YOURLIST) {
        @Override
        public void load() {

            /* do your stuff here */
            /* This method is automatically call while user reach at end of your list. */
        }
    };
    recycleCategory.setAdapter(adapter);

अब load() विधि स्वचालित रूप से कॉल करती है जबकि उपयोगकर्ता सूची के अंत में स्क्रॉल करता है।

अच्छी किस्मत

आइटम लोड होने या डेटा उपलब्ध नहीं होने तक डिफ़ॉल्ट दृश्य दिखाएं

स्क्रीनशॉट

एडॉप्टर क्लास

private class MyAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolder> {

final int EMPTY_VIEW = 77777;
List<CustomData> datalist = new ArrayList<>();

MyAdapter() {
    super();
}

@Override
public RecyclerView.ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {

    LayoutInflater layoutInflater = LayoutInflater.from(parent.getContext());

    if (viewType == EMPTY_VIEW) {
        return new EmptyView(layoutInflater.inflate(R.layout.nothing_yet, parent, false));
    } else {
        return new ItemView(layoutInflater.inflate(R.layout.my_item, parent, false));
    }
}

@SuppressLint("SetTextI18n")
@Override
public void onBindViewHolder(final RecyclerView.ViewHolder holder, int position) {
    if (getItemViewType(position) == EMPTY_VIEW) {
        EmptyView emptyView = (EmptyView) holder;
        emptyView.primaryText.setText("No data yet");
        emptyView.secondaryText.setText("You're doing good !");
        emptyView.primaryText.setCompoundDrawablesWithIntrinsicBounds(null, new IconicsDrawable(getActivity()).icon(FontAwesome.Icon.faw_ticket).sizeDp(48).color(Color.DKGRAY), null, null);

    } else {
        ItemView itemView = (ItemView) holder;
        // Bind data to itemView
    }
}

@Override
public int getItemCount() {
    return datalist.size() > 0 ? datalist.size() : 1;
}

@Override
public int getItemViewType(int position) {
    if  datalist.size() == 0) {
        return EMPTY_VIEW;
    }
    return super.getItemViewType(position);
}

}

nothing_yet.xml

<?xml version="1.0" encoding="utf-8"?>
<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:layout_gravity="center"
    android:orientation="vertical"
    android:paddingBottom="100dp"
    android:paddingTop="100dp">

    <TextView
        android:id="@+id/nothingPrimary"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_gravity="center"
        android:drawableTint="@android:color/secondary_text_light"
        android:drawableTop="@drawable/ic_folder_open_black_24dp"
        android:enabled="false"
        android:fontFamily="sans-serif-light"
        android:text="No Item's Yet"
        android:textAppearance="?android:attr/textAppearanceLarge"
        android:textColor="@android:color/secondary_text_light"
        android:textSize="40sp"
        tools:targetApi="m" />

    <TextView
        android:id="@+id/nothingSecondary"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_gravity="center_horizontal"
        android:enabled="false"
        android:fontFamily="sans-serif-condensed"
        android:text="You're doing good !"
        android:textAppearance="?android:attr/textAppearanceSmall"
        android:textColor="@android:color/tertiary_text_light" />
</LinearLayout>

मैं छवियों के लिए Iconics लाइब्रेरी के साथ FontAwesome का उपयोग कर रहा हूं। इसे अपने ऐप लेवल build.gradle फ़ाइल में जोड़ें।

compile 'com.mikepenz:fontawesome-typeface:4.6.0.3@aar'
compile 'com.mikepenz:iconics-core:2.8.1@aar'

RecyclerView आइटम में विभक्त लाइनें जोड़ें

बस इन लाइनों को आरंभीकरण में जोड़ें

RecyclerView mRecyclerView = (RecyclerView) view.findViewById(recyclerView);
mRecyclerView.setLayoutManager(new LinearLayoutManager(getActivity()));
mRecyclerView.addItemDecoration(new DividerItemDecoration(getActivity(), DividerItemDecoration.VERTICAL));

एक adapter जोड़ें और कॉल करें .notifyDataSetChanged(); हमेशा की तरह !
यह Recyclerview की एक इनबिल्ट सुविधा नहीं है, लेकिन समर्थन पुस्तकालयों में जोड़ा गया है। तो अपने ऐप लेवल बिल्ड.ग्रेड फ़ाइल में इसे शामिल करना न भूलें

compile "com.android.support:appcompat-v7:25.3.1"
compile "com.android.support:recyclerview-v7:25.3.1"

एकाधिक पुनर्नवीनीकरण एकल पुनर्नवीनीकरण दृश्य में जोड़े जा सकते हैं।

विभक्त रंग बदलना :

आइटमडीक्यूलेशन के लिए रंग सेट करना बहुत आसान है।

1. स्टेप यह है: एक divider.xml फ़ाइल बनाना जो divider.xml करने drawable फ़ोल्डर पर स्थित है

<?xml version="1.0" encoding="utf-8"?>
<shape xmlns:android="http://schemas.android.com/apk/res/android"
       android:shape="line">
    <size
        android:width="1px"
        android:height="1px"/>
    <solid android:color="@color/divider_color"/>
</shape>

2. चरण है: ड्रॉइंग सेट करना

    // Get drawable object
    Drawable mDivider = ContextCompat.getDrawable(m_jContext, R.drawable.divider);
    // Create a DividerItemDecoration whose orientation is Horizontal
    DividerItemDecoration hItemDecoration = new DividerItemDecoration(m_jContext,
            DividerItemDecoration.HORIZONTAL);
    // Set the drawable on it
    hItemDecoration.setDrawable(mDivider);

    // Create a DividerItemDecoration whose orientation is vertical
    DividerItemDecoration vItemDecoration = new DividerItemDecoration(m_jContext,
            DividerItemDecoration.VERTICAL);
    // Set the drawable on it
    vItemDecoration.setDrawable(mDivider);