RecyclerView की मदद से डाइनैमिक सूचियां बनाना   यह Android Jetpack का हिस्सा है.

Compose का इस्तेमाल करके मैसेज लिखना

Android के लिए, Jetpack Compose को यूज़र इंटरफ़ेस (यूआई) टूलकिट के तौर पर सुझाया जाता है. Compose में लेआउट इस्तेमाल करने का तरीका जानें.

लेज़ी लिस्ट और ग्रिड →

RecyclerView की मदद से, बड़े डेटा सेट को आसानी से दिखाया जा सकता है. आप डेटा उपलब्ध कराते हैं और यह तय करते हैं कि हर आइटम कैसा दिखेगा. इसके बाद, RecyclerView लाइब्रेरी ज़रूरत पड़ने पर एलिमेंट को डाइनैमिक तौर पर बनाती है.

जैसा कि नाम से पता चलता है, RecyclerView उन अलग-अलग एलिमेंट को रीसाइकल करता है. जब कोई आइटम स्क्रीन से स्क्रोल करके बाहर चला जाता है, तब RecyclerView उसका व्यू मिटा नहीं देता. इसके बजाय, RecyclerView, स्क्रीन पर स्क्रोल किए गए नए आइटम के लिए व्यू का फिर से इस्तेमाल करता है. RecyclerView से, ऐप्लिकेशन की परफ़ॉर्मेंस और तेज़ी से काम करने की सुविधा बेहतर होती है. साथ ही, इससे डिवाइस की बैटरी की खपत भी कम होती है.

मुख्य क्लास

आपकी डाइनैमिक सूची बनाने के लिए, कई क्लास एक साथ काम करती हैं.

• RecyclerView वह ViewGroup है जिसमें आपके डेटा से जुड़े व्यू शामिल होते हैं. यह एक व्यू है. इसलिए, अपने लेआउट में RecyclerView को उसी तरह जोड़ा जाता है जिस तरह किसी दूसरे यूज़र इंटरफ़ेस (यूआई) एलिमेंट को जोड़ा जाता है.

• सूची में मौजूद हर एलिमेंट को व्यू होल्डर ऑब्जेक्ट से तय किया जाता है. व्यू होल्डर बनाने पर, उससे कोई डेटा नहीं जुड़ा होता. व्यू होल्डर बनाने के बाद, RecyclerView उसे अपने डेटा से बाइंड करता है. RecyclerView.ViewHolder को बड़ा करके, व्यू होल्डर तय किया जाता है.

• RecyclerView, अडैप्टर में मौजूद तरीकों को कॉल करके, व्यू का अनुरोध करता है और व्यू को उनके डेटा से बांधता है. RecyclerView.Adapter को एक्सटेंड़ करके, अडैप्टर तय किया जाता है.

• लेआउट मैनेजर, आपकी सूची में मौजूद अलग-अलग एलिमेंट को व्यवस्थित करता है. RecyclerView लाइब्रेरी में दिए गए लेआउट मैनेजर में से किसी एक का इस्तेमाल किया जा सकता है. इसके अलावा, अपना लेआउट मैनेजर भी बनाया जा सकता है. सभी लेआउट मैनेजर, लाइब्रेरी के LayoutManager आब्स्ट्रैक्ट क्लास पर आधारित होते हैं.

RecyclerView के सैंपल ऐप्लिकेशन (Kotlin) या RecyclerView के सैंपल ऐप्लिकेशन (Java) में, यह देखा जा सकता है कि सभी चीज़ें एक साथ कैसे काम करती हैं.

RecyclerView लागू करने का तरीका

RecyclerView का इस्तेमाल करने के लिए, आपको कुछ काम करने होंगे. इनके बारे में नीचे दिए गए सेक्शन में पूरी जानकारी दी गई है.

1. यह तय करें कि सूची या ग्रिड कैसा दिखे. आम तौर पर, RecyclerView लाइब्रेरी के स्टैंडर्ड लेआउट मैनेजर में से किसी एक का इस्तेमाल किया जा सकता है.

2. सूची में मौजूद हर एलिमेंट को इस तरह डिज़ाइन करें कि वह कैसा दिखे और कैसे काम करे. इस डिज़ाइन के आधार पर, ViewHolder क्लास को बड़ा करें. ViewHolder का आपका वर्शन, आपकी सूची के आइटम के लिए सभी सुविधाएं उपलब्ध कराता है. आपका व्यू होल्डर, View के चारों ओर मौजूद एक रैपर है. साथ ही, उस व्यू को RecyclerView मैनेज करता है.

3. वह Adapter तय करें जो आपके डेटा को ViewHolder व्यू से जोड़ता है.

इसमें पसंद के मुताबिक बनाने के बेहतर विकल्प भी हैं. इनकी मदद से, RecyclerView को अपनी ज़रूरत के मुताबिक बनाया जा सकता है.

लेआउट का प्लान बनाना

आपके RecyclerView में मौजूद आइटम, LayoutManager क्लास के हिसाब से व्यवस्थित किए जाते हैं. RecyclerView लाइब्रेरी में तीन लेआउट मैनेजर होते हैं, जो लेआउट से जुड़ी आम समस्याओं को हल करते हैं:

• LinearLayoutManager आइटम को एक डाइमेंशन वाली सूची में व्यवस्थित करता है.
• GridLayoutManager आइटम को दो-आयामी ग्रिड में व्यवस्थित करता है:
  • अगर ग्रिड को वर्टिकल तौर पर व्यवस्थित किया जाता है, तो GridLayoutManager हर पंक्ति में मौजूद सभी एलिमेंट की चौड़ाई और ऊंचाई एक जैसी रखने की कोशिश करता है. हालांकि, अलग-अलग पंक्तियों की ऊंचाई अलग-अलग हो सकती है.
  • अगर ग्रिड को हॉरिज़ॉन्टल तौर पर व्यवस्थित किया जाता है, तो GridLayoutManager हर कॉलम के सभी एलिमेंट की चौड़ाई और ऊंचाई एक जैसी रखने की कोशिश करता है. हालांकि, अलग-अलग कॉलम की चौड़ाई अलग-अलग हो सकती है.
• StaggeredGridLayoutManager, GridLayoutManager से मिलता-जुलता है. हालांकि, इसके लिए ज़रूरी नहीं है कि वर्टिकल ग्रिड के लिए, पंक्ति में मौजूद आइटम की ऊंचाई एक जैसी हो या हॉरिज़ॉन्टल ग्रिड के लिए, एक ही कॉलम में मौजूद आइटम की चौड़ाई एक जैसी हो. इस वजह से, किसी पंक्ति या कॉलम में मौजूद आइटम, एक-दूसरे से अलग हो सकते हैं.

आपको अलग-अलग आइटम का लेआउट भी डिज़ाइन करना होगा. अगले सेक्शन में बताए गए तरीके से व्यू होल्डर डिज़ाइन करते समय, आपको इस लेआउट की ज़रूरत होगी.

अपना अडैप्टर और व्यू होल्डर लागू करना

लेआउट तय करने के बाद, आपको Adapter और ViewHolder लागू करने होंगे. ये दोनों क्लास एक साथ काम करके यह तय करती हैं कि आपका डेटा कैसे दिखेगा. ViewHolder, View के चारों ओर मौजूद एक रैपर है. इसमें सूची में मौजूद किसी आइटम का लेआउट होता है. Adapter, ज़रूरत के हिसाब से ViewHolder ऑब्जेक्ट बनाता है. साथ ही, उन व्यू के लिए डेटा भी सेट करता है. व्यू को उनके डेटा से जोड़ने की प्रोसेस को बाइंड करना कहते हैं.

अडैप्टर तय करते समय, तीन मुख्य तरीकों को बदला जाता है:

• onCreateViewHolder(): RecyclerView जब भी कोई नया ViewHolder बनाना हो, तब वह इस तरीके को कॉल करता है. यह तरीका, ViewHolder और उससे जुड़े View को बनाता और शुरू करता है, लेकिन व्यू के कॉन्टेंट को नहीं भरता—ViewHolder को अब तक किसी खास डेटा से बाउंड नहीं किया गया है.

• onBindViewHolder(): RecyclerView, डेटा के साथ ViewHolder को जोड़ने के लिए इस तरीके को कॉल करता है. यह तरीका, ज़रूरी डेटा फ़ेच करता है और व्यूहोल्डर के लेआउट को भरने के लिए डेटा का इस्तेमाल करता है. उदाहरण के लिए, अगर RecyclerView में नामों की सूची दिखती है, तो हो सकता है कि यह तरीका सूची में सही नाम ढूंढकर, व्यूहोल्डर के TextView विजेट में भर दे.

• getItemCount(): RecyclerView, डेटासेट का साइज़ पाने के लिए इस तरीके को कॉल करता है. उदाहरण के लिए, किसी पता वाली डायरी वाले ऐप्लिकेशन में, यह पतों की कुल संख्या हो सकती है. RecyclerView इसका इस्तेमाल यह तय करने के लिए करता है कि अब और कौनसे आइटम दिखाए जा सकते हैं.

यहां नेस्ट किए गए ViewHolder वाले एक सामान्य अडैप्टर का उदाहरण दिया गया है, जो डेटा की सूची दिखाता है. इस मामले में, RecyclerView टेक्स्ट एलिमेंट की एक आसान सूची दिखाता है. अडैप्टर को स्ट्रिंग का एक कलेक्शन दिया जाता है, जिसमें ViewHolder एलिमेंट के लिए टेक्स्ट होता है.

class CustomAdapter(private val dataSet: Array<String>) :
        RecyclerView.Adapter<CustomAdapter.ViewHolder>() {

    /**
     * Provide a reference to the type of views that you are using
     * (custom ViewHolder)
     */
    class ViewHolder(view: View) : RecyclerView.ViewHolder(view) {
        val textView: TextView

        init {
            // Define click listener for the ViewHolder's View
            textView = view.findViewById(R.id.textView)
        }
    }

    // Create new views (invoked by the layout manager)
    override fun onCreateViewHolder(viewGroup: ViewGroup, viewType: Int): ViewHolder {
        // Create a new view, which defines the UI of the list item
        val view = LayoutInflater.from(viewGroup.context)
                .inflate(R.layout.text_row_item, viewGroup, false)

        return ViewHolder(view)
    }

    // Replace the contents of a view (invoked by the layout manager)
    override fun onBindViewHolder(viewHolder: ViewHolder, position: Int) {

        // Get element from your dataset at this position and replace the
        // contents of the view with that element
        viewHolder.textView.text = dataSet[position]
    }

    // Return the size of your dataset (invoked by the layout manager)
    override fun getItemCount() = dataSet.size

}

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

    private String[] localDataSet;

    /**
     * Provide a reference to the type of views that you are using
     * (custom ViewHolder)
     */
    public static class ViewHolder extends RecyclerView.ViewHolder {
        private final TextView textView;

        public ViewHolder(View view) {
            super(view);
            // Define click listener for the ViewHolder's View

            textView = (TextView) view.findViewById(R.id.textView);
        }

        public TextView getTextView() {
            return textView;
        }
    }

    /**
     * Initialize the dataset of the Adapter
     *
     * @param dataSet String[] containing the data to populate views to be used
     * by RecyclerView
     */
    public CustomAdapter(String[] dataSet) {
        localDataSet = dataSet;
    }

    // Create new views (invoked by the layout manager)
    @Override
    public ViewHolder onCreateViewHolder(ViewGroup viewGroup, int viewType) {
        // Create a new view, which defines the UI of the list item
        View view = LayoutInflater.from(viewGroup.getContext())
                .inflate(R.layout.text_row_item, viewGroup, false);

        return new ViewHolder(view);
    }

    // Replace the contents of a view (invoked by the layout manager)
    @Override
    public void onBindViewHolder(ViewHolder viewHolder, final int position) {

        // Get element from your dataset at this position and replace the
        // contents of the view with that element
        viewHolder.getTextView().setText(localDataSet[position]);
    }

    // Return the size of your dataset (invoked by the layout manager)
    @Override
    public int getItemCount() {
        return localDataSet.length;
    }
}

हर व्यू आइटम का लेआउट, हमेशा की तरह एक्सएमएल लेआउट फ़ाइल में तय किया जाता है. इस मामले में, ऐप्लिकेशन में इस तरह की text_row_item.xml फ़ाइल है:

<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="@dimen/list_item_height"
    android:layout_marginLeft="@dimen/margin_medium"
    android:layout_marginRight="@dimen/margin_medium"
    android:gravity="center_vertical">

    <TextView
        android:id="@+id/textView"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="@string/element_text"/>
</FrameLayout>

अगले चरण

यहां दिए गए कोड स्निपेट में, RecyclerView का इस्तेमाल करने का तरीका बताया गया है.

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        val dataset = arrayOf("January", "February", "March")
        val customAdapter = CustomAdapter(dataset)

        val recyclerView: RecyclerView = findViewById(R.id.recycler_view)
        recyclerView.layoutManager = LinearLayoutManager(this)
        recyclerView.adapter = customAdapter

    }

}

RecyclerView recyclerView = findViewById(R.id.recycler_view);
recyclerView.layoutManager = new LinearLayoutManager(this)
recyclerView.setAdapter(customAdapter);

लाइब्रेरी में, लागू करने के तरीके को पसंद के मुताबिक बनाने के कई तरीके भी उपलब्ध हैं. ज़्यादा जानकारी के लिए, RecyclerView को पसंद के मुताबिक बनाने का बेहतर तरीका लेख पढ़ें.

अन्य संसाधन

Android पर टेस्टिंग के बारे में ज़्यादा जानकारी के लिए, यहां दिए गए संसाधन देखें.

सैंपल ऐप्लिकेशन

• RecyclerView का सैंपल ऐप्लिकेशन (Kotlin)

• RecyclerView का सैंपल ऐप्लिकेशन (Java)

• Sunflower का डेमो ऐप्लिकेशन