जावा लिस्ट: शुरुआती और डेवलपर्स के लिए एक व्यापक गाइड

1. परिचय

जावा में List का महत्व क्या है?

जावा प्रोग्रामिंग में, “List” एक डेटा संरचना है जो बहुत बार उपयोग में आती है। विशेष रूप से उन स्थितियों में जहाँ आप कई मानों को साथ‑साथ प्रबंधित करना चाहते हैं, यह एरे की तुलना में अधिक लचीला और उपयोग में आसान होता है, जिससे यह कई व्यावहारिक परिदृश्यों में अत्यधिक मूल्यवान बन जाता है।
“List” जावा कलेक्शन्स फ्रेमवर्क का एक कोर इंटरफ़ेस है और यह ArrayList, LinkedList जैसी विभिन्न कार्यान्वयन क्लासेज़ के माध्यम से विभिन्न परिस्थितियों को संभालने का तंत्र प्रदान करता है। डेटा को जोड़ना, हटाना, खोज करना और अपडेट करना जैसी क्रियाओं को सहजता से करने की क्षमता ही List को पसंद किया जाने का मुख्य कारण है।

इस लेख का उद्देश्य और लक्षित पाठक वर्ग

यह लेख “Java List” को बुनियादी से उन्नत विषयों तक व्यवस्थित रूप से समझाने के लिए तैयार किया गया है, जिससे शुरुआती भी आसानी से समझ सकें। मुख्य लक्षित पाठक वर्ग इस प्रकार है:

• वे लोग जो अभी जावा सीखना शुरू कर रहे हैं और List का उपयोग कैसे करें, इस बारे में अनिश्चित हैं
• वे लोग जो Array और List के बीच का अंतर स्पष्ट रूप से समझना चाहते हैं
• वे लोग जो ArrayList और LinkedList के चयन में उलझे हुए हैं
• वे लोग जो व्यावहारिक रूप से List का उपयोग करने से पहले मूल बातें दोबारा देखना चाहते हैं

लेख को पढ़ने के बाद, हमारा लक्ष्य है कि आप List के मूल सिद्धांत, कार्यान्वयन विधियाँ और विशिष्ट ऑपरेशन्स को ठोस रूप से समझें, जिससे आप आत्मविश्वास के साथ कोड लिख सकें। अगले अध्याय से हम क्रमशः मूल भाग, “List क्या है?” को समझाते हुए आगे बढ़ेंगे।

2. List क्या है?

List का अवलोकन और विशेषताएँ

जावा में “List” एक कलेक्शन इंटरफ़ेस है जो तत्वों को क्रमबद्ध अनुक्रम में रखता है। इसकी सबसे बड़ी विशेषताएँ हैं कि तत्व जोड़ने का क्रम संरक्षित रहता है और व्यक्तिगत तत्वों को इंडेक्स (0 से शुरू) के माध्यम से एक्सेस किया जा सकता है।
List को कलेक्शन्स फ्रेमवर्क का हिस्सा के रूप में प्रदान किया गया है और इसमें निम्नलिखित गुण हैं:

• डुप्लिकेट तत्वों की अनुमति देता है
• इंडेक्स निर्दिष्ट करके तत्वों को प्राप्त, अपडेट और डिलीट किया जा सकता है
• तत्वों की संख्या को गतिशील रूप से बढ़ाया या घटाया जा सकता है (एरे के विपरीत, यह स्थिर आकार नहीं है)

इन सुविधाओं के कारण लचीला डेटा हेरफेर संभव होता है और यह व्यावहारिक कार्यों में बहुत बार उपयोग किया जाता है।

Array से अंतर

जावा में एरे (जैसे int[] या String[]) भी कई मानों को रखने का एक साधन है, लेकिन List से कई पहलुओं में अंतर है।

इस प्रकार, List अधिक लचीला और फीचर‑समृद्ध कलेक्शन है, जो कई स्थितियों में एरे की तुलना में अधिक व्यावहारिक बनाता है।

List इंटरफ़ेस और उसकी कार्यान्वयन क्लासेज़

जावा में List का उपयोग करते समय आमतौर पर आप List इंटरफ़ेस के माध्यम से एक वेरिएबल घोषित करते हैं और किसी विशिष्ट क्लास (इम्प्लीमेंटेशन क्लास) की इंस्टेंस बनाते हैं। प्रमुख कार्यान्वयन क्लासेज़ इस प्रकार हैं:

• ArrayList – एरे के समान संरचना, तेज़ एक्सेस की सुविधा। डेटा खोज और रैंडम एक्सेस में मजबूत।
• LinkedList – द्वि‑दिशात्मक लिंक्ड लिस्ट संरचना पर आधारित। इन्सर्शन और डिलीशन में तेज़, उन सूचियों के लिए उपयुक्त जहाँ ये ऑपरेशन बार‑बार होते हैं।
• Vector – ArrayList के समान लेकिन थ्रेड‑सेफ़ होने के कारण थोड़ा भारी। आजकल कम उपयोग में आता है।

आम तौर पर, ArrayList सबसे अधिक उपयोग किया जाता है, जब तक कि कोई विशेष कारण न हो। बाद में वर्णित प्रदर्शन तुलना के आधार पर उपयोग केस के अनुसार उपयुक्त क्लास चुनना उचित रहेगा।

3. List का बुनियादी उपयोग

यह अनुभाग जावा में List का उपयोग करते समय किए जाने वाले बुनियादी ऑपरेशन्स को क्रमशः समझाता है। यहाँ हम मुख्यतः ArrayList को उदाहरण के रूप में लेकर List के प्रतिनिधि ऑपरेशन्स को प्रस्तुत करेंगे।

List की घोषणा और प्रारम्भिककरण

पहले, ArrayList का उपयोग करके List की बुनियादी घोषणा और प्रारम्भिककरण को देखें।

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> fruits = new ArrayList<>();
    }
}

यह सामान्य प्रथा है कि एक वेरिएबल को List इंटरफ़ेस के साथ घोषित किया जाए और उसे ArrayList के साथ इंस्टैंसिएट किया जाए। जेनरिक्स का उपयोग संग्रहीत किए जाने वाले प्रकार को निर्दिष्ट करने के लिए किया जाता है (यहाँ, String)।

तत्व जोड़ना (add)

List में तत्व जोड़ने के लिए add() मेथड का उपयोग करें।

fruits.add("apple");
fruits.add("banana");
fruits.add("orange");

यह क्रम में List में तीन तत्व जोड़ता है। List जोड़ने के क्रम को बनाए रखता है।

तत्व प्राप्त करना (get)

निर्दिष्ट इंडेक्स पर तत्व प्राप्त करने के लिए get(int index) का उपयोग करें।

System.out.println(fruits.get(0)); // "apple" will be displayed

ध्यान दें कि इंडेक्स 0 से शुरू होते हैं।

तत्व अपडेट करना (set)

किसी निश्चित स्थिति पर तत्व को अपडेट करने के लिए set(int index, E element) का उपयोग करें।

fruits.set(1, "grape"); // The second element "banana" is replaced with "grape"

तत्व हटाना (remove)

आप किसी विशिष्ट इंडेक्स या स्वयं तत्व को हटाकर भी हटा सकते हैं।

fruits.remove(0);           // Removes the first element
fruits.remove("orange");    // Removes "orange" (only the first match)

List का आकार प्राप्त करना (size)

वर्तमान तत्वों की संख्या size() मेथड से प्राप्त की जा सकती है।

System.out.println(fruits.size()); // Returns 2, etc.

तत्व की उपस्थिति जाँचना (contains)

किसी विशिष्ट तत्व के List में शामिल होने की जाँच करने के लिए contains() का उपयोग करें।

if (fruits.contains("grape")) {
    System.out.println("grape is present");
}

सारांश: अक्सर उपयोग किए जाने वाले बुनियादी ऑपरेशन्स की सूची

4. List ऑपरेशन उदाहरण

इस अध्याय में, हम Java की List का उपयोग करके व्यावहारिक ऑपरेशन उदाहरण प्रस्तुत करेंगे। कई स्थितियों में आप सूची के तत्वों को क्रमिक रूप से प्रोसेस करना चाहते हैं, और यहाँ हम for लूप, enhanced for लूप, और Stream API का उपयोग करके प्रतिनिधि विधियों को कवर करेंगे।

for लूप का उपयोग करके इटरेशन

सबसे बुनियादी विधि है कि for लूप के भीतर इंडेक्स का उपयोग करके तत्वों को प्राप्त किया जाए।

List<String> fruits = new ArrayList<>();
fruits.add("apple");
fruits.add("banana");
fruits.add("orange");

for (int i = 0; i < fruits.size(); i++) {
    System.out.println(fruits.get(i));
}

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

enhanced for लूप (for-each) का उपयोग करके इटरेशन

यदि आप इंडेक्स की परवाह किए बिना सभी तत्वों को क्रमिक रूप से प्रोसेस करना चाहते हैं, तो enhanced for लूप सुविधाजनक है।

for (String fruit : fruits) {
    System.out.println(fruit);
}

सिंटैक्स सरल और पढ़ने में आसान है, जिससे यह सबसे अधिक उपयोग की जाने वाली विधियों में से एक बन जाता है। यह साधारण प्रोसेसिंग के लिए पर्याप्त है।

Lambda एक्सप्रेशन और Stream API का उपयोग करके इटरेशन

Java 8 से, आप Stream API और लैम्ब्डा एक्सप्रेशन के साथ सिंटैक्स का भी उपयोग कर सकते हैं।

fruits.stream().forEach(fruit -> System.out.println(fruit));

इस नोटेशन की ताकत यह है कि कई प्रोसेस को एक साथ चेन किया जा सकता है। उदाहरण के लिए, आप आसानी से फ़िल्टर कर सकते हैं और फिर विशिष्ट मानदंड के आधार पर तत्वों को प्रिंट कर सकते हैं।

fruits.stream()
      .filter(fruit -> fruit.contains("a"))
      .forEach(System.out::println);

इस उदाहरण में, यह केवल उन फलों को प्रिंट करता है जिनमें “a” शामिल है। यह उन लोगों के लिए विशेष रूप से अनुशंसित है जो फ़ंक्शनल स्टाइल कोडिंग के आदी होना चाहते हैं।

सही विधि का चयन

5. ArrayList और LinkedList के अंतर और उपयोग

Java की List इंटरफ़ेस को लागू करने वाली प्रमुख क्लासें ArrayList और LinkedList हैं। दोनों को समान रूप से List के रूप में उपयोग किया जा सकता है, लेकिन उनकी आंतरिक संरचना और प्रदर्शन विशेषताओं में अंतर है, इसलिए सही परिस्थितियों में उनका उचित उपयोग करना महत्वपूर्ण है।

ArrayList की विशेषताएँ और उपयुक्त उपयोग केस

ArrayList आंतरिक रूप से एक डायनामिक एरे (रिसाइज़ेबल एरे) का उपयोग करता है।

• बहुत तेज़ रैंडम एक्सेस (इंडेक्स-आधारित)
• सूची के अंत में तत्व जोड़ना तेज़ है (औसत O(1))
• मध्य में सम्मिलन और विलोपन धीमे होते हैं (O(n))

उपयुक्त स्थितियाँ:

• ऐसी स्थितियाँ जहाँ खोज (get()) बार‑बार की जाती है
• ऐसी स्थितियाँ जहाँ तत्वों की संख्या को पहले से कुछ हद तक अनुमानित किया जा सकता है
• ऐसी प्रोसेसिंग जहाँ तत्व जोड़ना/हटाना न्यूनतम हो, मुख्यतः पढ़ने पर ध्यान केंद्रित हो

  List<String> list = new ArrayList<>();
  

LinkedList की विशेषताएँ और उपयुक्त उपयोग केस

LinkedList को डबल्ली लिंक्ड लिस्ट संरचना के साथ लागू किया गया है।

मुख्य विशेषताएँ:

• तत्वों को जोड़ना और हटाना तेज़ (विशेषकर शुरुआत या अंत में)
• रैंडम एक्सेस (get(index)) धीमा है (O(n))
• मेमोरी खपत ArrayList की तुलना में थोड़ी अधिक होती है

उपयुक्त स्थितियाँ:

• ऐसी स्थितियाँ जहाँ तत्व अक्सर सम्मिलित या हटाए जाते हैं (विशेषकर शुरुआत या मध्य में)
• जब आप इसे Queue या Stack की तरह उपयोग करना चाहते हैं
• जब इटरेशन पर ध्यान हो और इंडेक्स एक्सेस की आवश्यकता न हो

  List<String> list = new LinkedList<>();
  

प्रदर्शन तुलना

निम्न तालिका सामान्यतः उपयोग किए जाने वाले ऑपरेशनों के सैद्धांतिक समय जटिलता (Big O नोटेशन) को दर्शाती है।

* वास्तविक प्रोसेसिंग समय डेटा आकार, JVM अनुकूलन आदि से भी प्रभावित हो सकता है।

व्यावहारिक उपयोग में अंतर के बिंदु

• यदि आप डेटा को सूची के रूप में उपयोग कर रहे हैं और इंडेक्स द्वारा एक्सेस कर रहे हैं, तो ArrayList का उपयोग करें
• यदि शुरुआत या मध्य में सम्मिलन/विलोपन बार‑बार होता है, तो LinkedList का उपयोग करें
• प्रदर्शन‑संवेदनशील प्रोसेसिंग के लिए हमेशा बेंचमार्क करें और सत्यापित करें

6. List का उन्नत उपयोग

यहाँ हम Java की List को और अधिक सुविधाजनक रूप से उपयोग करने की उन्नत तकनीकों का परिचय देंगे। List केवल डेटा के साधारण संग्रह के रूप में नहीं, बल्कि सॉर्टिंग, शफ़लिंग, फ़िल्टरिंग, ट्रांसफ़ॉर्मेशन आदि के माध्यम से विभिन्न कार्य कर सकती है।

List को सॉर्ट करना (Collections.sort)

Collections.sort() का उपयोग करके आप List के तत्वों को आरोही क्रम में सॉर्ट कर सकते हैं। तत्वों को Comparable इंटरफ़ेस को लागू करना आवश्यक है।

import java.util.*;

List<String> fruits = new ArrayList<>();
fruits.add("banana");
fruits.add("apple");
fruits.add("orange");

Collections.sort(fruits);

System.out.println(fruits); // [apple, banana, orange]

कस्टम क्रम में सॉर्ट करना (Comparator का उपयोग)

fruits.sort(Comparator.reverseOrder()); // Sorts in descending order

List को शफ़ल करना (Collections.shuffle)

तत्वों को यादृच्छिक क्रम में पुनर्व्यवस्थित करने के लिए आप Collections.shuffle() का उपयोग कर सकते हैं।

Collections.shuffle(fruits);
System.out.println(fruits); // [banana, orange, apple] (example)

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

Stream API के साथ फ़िल्टरिंग (filter)

Java 8 से उपलब्ध Stream का उपयोग करके आप संक्षिप्त कोड में केवल उन तत्वों को निकाल सकते हैं जो किसी शर्त को पूरा करते हैं।

List<String> filtered = fruits.stream()
    .filter(fruit -> fruit.contains("a"))
    .collect(Collectors.toList());

System.out.println(filtered); // [apple, banana, orange] (depending on original content and filter)

Stream API के साथ ट्रांसफ़ॉर्मेशन (map)

तत्वों को किसी अलग प्रारूप में बदलने के लिए map() का उपयोग करें।

List<Integer> lengths = fruits.stream()
    .map(String::length)
    .collect(Collectors.toList());

System.out.println(lengths); // Lengths of each fruit name [5, 6, 6] etc.

map() डेटा फ़ॉर्मेट परिवर्तन और प्री‑प्रोसेसिंग के लिए एक शक्तिशाली उपकरण है।

उन्नत ऑपरेशनों का सारांश

7. सामान्य त्रुटियाँ और उनके समाधान

Java में List के साथ काम करते समय शुरुआती अक्सर “अपवाद (त्रुटियाँ)” का सामना करते हैं। यहाँ हम अक्सर होने वाले प्रतिनिधि त्रुटियों, उनके कारणों और समाधान को विशेष रूप से समझाएँगे।

IndexOutOfBoundsException

कारण:

ऐसे इंडेक्स तक पहुँचने की कोशिश करने पर उत्पन्न होता है जो मौजूद नहीं है।

List<String> list = new ArrayList<>();
list.add("apple");

System.out.println(list.get(1)); // Error: Index 1 out of bounds

समाधान:

इंडेक्स वैध होने को सुनिश्चित करने के लिए एक्सेस करने से पहले आकार जाँचें या शर्तीय शाखा के साथ एक्सेस को नियंत्रित करें।

if (list.size() > 1) {
    System.out.println(list.get(1));
}

NullPointerException

कारण:

जब किसी List या List के तत्व पर null होने पर कोई मेथड कॉल किया जाता है, तब यह उत्पन्न होता है।

List<String> list = null;
list.add("apple"); // NullPointerException occurs

समाधान:

पहले से जाँचें कि वेरिएबल null नहीं है, या Optional आदि का उपयोग करें।

if (list != null) {
    list.add("apple");
}

साथ ही, इनिशियलाइज़ करना भूलने से सावधान रहें:

List<String> list = new ArrayList<>(); // Correct initialization

ConcurrentModificationException

कारण:

जब List को for-each लूप या Iterator का उपयोग करके इटररेट करते समय सीधे संशोधित किया जाता है, तब यह उत्पन्न होता है।

for (String fruit : list) {
    if (fruit.equals("banana")) {
        list.remove(fruit); // ConcurrentModificationException
    }
}

समाधान:

Iterator का उपयोग करके तत्वों को सुरक्षित रूप से हटाएँ, या removeIf() जैसी विधियों का उपयोग करें।

Iterator<String> it = list.iterator();
while (it.hasNext()) {
    if (it.next().equals("banana")) {
        it.remove(); // Safe removal
    }
}

या, Java 8 से आगे अधिक संक्षिप्त रूप में:

list.removeIf(fruit -> fruit.equals("banana"));

अन्य महत्वपूर्ण बिंदु

• List null नहीं है, यह जाँचना
• अक्सर वेरिएबल घोषित किया जाता है लेकिन उपयोग नहीं किया जाता। इनिशियलाइज़ेशन आवश्यक है।
• समझना कि इंडेक्स 0 से शुरू होते हैं
• शुरुआती अक्सर गलती से सोचते हैं कि “पहला तत्व इंडेक्स 1 है”।

त्रुटि निवारण सारांश

8. निष्कर्ष

Java List की मूल बातें की समीक्षा

इस लेख में, हमने Java में List की बुनियादी से उन्नत पहलुओं को क्रमवार समझाया है। List Java संग्रहों में विशेष रूप से अक्सर उपयोग की जाती है और यह डेटा को लचीले ढंग से संभालने के लिए एक महत्वपूर्ण उपकरण है।
पहले, List क्या है इसे समझने के बाद, हमने निम्नलिखित बिंदु सीखे:

• List एक क्रमबद्ध संग्रह है जो डुप्लिकेट की अनुमति देता है और इंडेक्स ऑपरेशन्स को सपोर्ट करता है
• ArrayList और LinkedList जैसी प्रतिनिधि इम्प्लीमेंटेशन क्लासें हैं, प्रत्येक की अलग विशेषताएँ और उपयोग केस हैं
• बुनियादी ऑपरेशन्स (add, get, update, remove, search) में निपुणता लचीले डेटा हेरफेर की अनुमति देती है
• स्थिति के अनुसार उपयुक्त इटरेटिव प्रोसेसिंग, जैसे for लूप, एन्हांस्ड for लूप, और Stream API
• सॉर्टिंग, फ़िल्टरिंग, और ट्रांसफ़ॉर्मेशन जैसी उन्नत ऑपरेशन्स को सपोर्ट करता है
• सामान्य त्रुटियों, उनके कारणों, और समाधान को समझना समस्याओं को रोकने में मदद करता है

ArrayList और LinkedList उपयोग में अंतर

कौन सा List इम्प्लीमेंटेशन उपयोग करना है, यह चुनना महत्वपूर्ण है और इसे प्रोसेसिंग की सामग्री और डेटा की मात्रा के आधार पर होना चाहिए। निम्नलिखित मानदंड मार्गदर्शक के रूप में काम कर सकते हैं:

• ArrayList : बार-बार रैंडम एक्सेस, मुख्यतः पढ़ना
• LinkedList : बार-बार इन्सर्शन/डिलीशन, एक्सेस का क्रम महत्वपूर्ण

भविष्य की सीख की ओर

List केवल Java के संग्रहों का “प्रवेश बिंदु” है। अधिक उन्नत डेटा संरचनाओं और उपयोगिताओं को संभालने के लिए, निम्नलिखित क्लासों और सुविधाओं की समझ को गहरा करने की सलाह दी जाती है:

• Set और Map : अद्वितीय तत्वों का प्रबंधन, कुंजी-मूल्य जोड़ी संरचना
• Collections उपयोगिता क्लास : सॉर्टिंग, न्यूनतम/अधिकतम खोज आदि
• Stream API का उपयोग : फ़ंक्शनल प्रोग्रामिंग का परिचय
• Generics को समझना : टाइप-सेफ संग्रह ऑपरेशन्स

List की बुनियादी बातों में निपुणता आपके समग्र Java प्रोग्रामिंग को काफी आसान प्रबंधनीय बना देगी।

अक्सर पूछे जाने वाले प्रश्न (FAQ)

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

प्रश्न 1. Java की List और Array में क्या अंतर है?

A. एक एरे में तत्वों की संख्या निश्चित होती है और इसका आकार घोषणा के समय निर्धारित करना पड़ता है। दूसरी ओर, एक List का आकार परिवर्तनीय होता है, जिससे तत्वों को लचीले ढंग से जोड़ा और हटाया जा सकता है। इसके अलावा, List में कई सुविधाजनक मेथड्स (add, remove, contains, आदि) होते हैं और यह पठनीयता और रखरखाव के मामले में बेहतर है।

Q2. मुझे कौन सा उपयोग करना चाहिए, ArrayList या LinkedList?

A. ArrayList मुख्यतः तब उपयुक्त होता है जब अक्सर रैंडम एक्सेस (इंडेक्स द्वारा पुनर्प्राप्ति) की आवश्यकता होती है। LinkedList तब उपयुक्त होता है जब तत्वों का सम्मिलन और विलोपन बार-बार होता है। यदि आप अनिश्चित हैं, तो सामान्यतः ArrayList से शुरू करना अनुशंसित है।

Q3. क्या मैं प्रिमिटिव टाइप्स (जैसे int या double) को List में स्टोर कर सकता हूँ?

A. सीधे नहीं। चूँकि Java की List केवल ऑब्जेक्ट टाइप्स को संभालती है, इसलिए प्रिमिटिव टाइप्स जैसे int के लिए आपको उनके संबंधित रैपर क्लासेज़ (Integer, Double, आदि) का उपयोग करना होगा।

List<Integer> numbers = new ArrayList<>();
numbers.add(10); // Auto-boxed and stored as Integer type

Q4. मैं List में तत्वों को कैसे सॉर्ट कर सकता हूँ?

A. आप Collections.sort(list) का उपयोग करके आरोही क्रम में सॉर्ट कर सकते हैं। यदि आप कस्टम क्रम में सॉर्ट करना चाहते हैं, तो आप लचीले क्रम के लिए एक Comparator निर्दिष्ट कर सकते हैं।

Q5. यदि मैं डुप्लिकेट्स के बिना तत्वों का प्रबंधन करना चाहता हूँ तो मुझे क्या करना चाहिए?

A. List एक ऐसी कलेक्शन है जो डुप्लिकेट्स की अनुमति देती है। यदि आप डुप्लिकेट्स से बचना चाहते हैं, तो Set (जैसे HashSet) का उपयोग करने पर विचार करें। हालांकि, ध्यान रखें कि क्रम की गारंटी नहीं होती। यदि आप List ही रखना चाहते हुए डुप्लिकेट्स हटाना चाहते हैं, तो निम्नलिखित Stream प्रोसेसिंग भी संभव है:

List<String> distinctList = list.stream()
    .distinct()
    .collect(Collectors.toList());

Q6. जब मैं List से सभी तत्वों को साफ़ करना चाहता हूँ तो मैं क्या करूँ?

A. आप clear() मेथड का उपयोग करके List से सभी तत्वों को हटा सकते हैं।

list.clear();

Q7. List में सबसे अधिक उपयोग किए जाने वाले ऑपरेशन्स कौन से हैं?

A. व्यावहारिक रूप से सबसे अधिक उपयोग किए जाने वाले ऑपरेशन्स add (जोड़ना), get (प्राप्त करना), remove (हटाना), और size (आकार प्राप्त करना) हैं। इनको महारत हासिल करने से अधिकांश बुनियादी प्रोसेसिंग कवर हो जाएगी।