- 1 1. परिचय
- 2 2. सूची क्या है?
- 3 3. सूची का मूल उपयोग
- 4 4. List ऑपरेशन उदाहरण
- 5 5. ArrayList और LinkedList के अंतर और उपयोग
- 6 6. List का उन्नत उपयोग
- 7 7. सामान्य त्रुटियाँ और उनके समाधान
- 8 8. निष्कर्ष
- 9 अक्सर पूछे जाने वाले प्रश्न (FAQ)
- 9.1 Q1. जावा की List और Array में क्या अंतर है?
- 9.2 Q2. मुझे ArrayList या LinkedList में से कौन सा उपयोग करना चाहिए?
- 9.3 Q3. क्या मैं List में primitive प्रकार (जैसे int या double) रख सकता हूँ?
- 9.4 Q4. मैं List में तत्वों को कैसे क्रमबद्ध कर सकता हूँ?
- 9.5 Q5. यदि मैं तत्वों को बिना डुप्लिकेट के प्रबंधित करना चाहता हूँ तो मुझे क्या करना चाहिए?
- 9.6 Q6. जब मैं List से सभी तत्व हटाना चाहता हूँ तो मैं क्या करूँ?
- 9.7 Q7. List में सबसे अधिक उपयोग किए जाने वाले ऑपरेशन कौन से हैं?
1. परिचय
जावा में सूची का महत्व क्या है?
जावा प्रोग्रामिंग में, “सूची” एक डेटा संरचना है जो बहुत बार दिखाई देती है। विशेष रूप से उन स्थितियों में जहां आप कई मानों को एक साथ प्रबंधित करना चाहते हैं, यह सरणियों की तुलना में अधिक लचीली और उपयोग करने में आसान है, जिससे यह कई व्यावहारिक परिदृश्यों में अत्यधिक मूल्यवान हो जाती है।
“सूची” जावा संग्रह फ्रेमवर्क में एक कोर इंटरफेस है और सरणी सूची और लिंक्ड सूची जैसी विभिन्न कार्यान्वयन कक्षाओं के माध्यम से विभिन्न स्थितियों को संभालने के लिए एक तंत्र प्रदान करती है। डेटा जोड़ने, हटाने, खोजने और अपडेट करने जैसे संचालनों को सहज रूप से करने की क्षमता सूची को पसंद किए जाने का एक कारण है।
इस लेख का उद्देश्य और लक्षित दर्शक
यह लेख “जावा सूची” को आधारभूत से उन्नत विषयों तक प्रारंभिक लोगों के लिए आसानी से समझने योग्य तरीके से व्यवस्थित रूप से समझाएगा। मुख्य लक्षित दर्शक निम्नलिखित हैं:
- जो जावा सीखना अभी शुरू कर रहे हैं और सूची का उपयोग कैसे करें, इस बारे में अनिश्चित हैं
- जो सरणी और सूची के बीच अंतर को स्पष्ट रूप से समझना चाहते हैं
- जो सरणी सूची और लिंक्ड सूची के बीच चयन करने में संघर्ष कर रहे हैं
- जो सूची को व्यावहारिक रूप से उपयोग करने से पहले आधारभूत को संशोधित करना चाहते हैं
इस लेख को पढ़ने के अंत तक, हमारा लक्ष्य है कि आपको जावा में सूची के मूल अवधारणाओं, कार्यान्वयन विधियों और विशिष्ट संचालनों की मजबूत समझ प्राप्त हो, जिससे आप आत्मविश्वास के साथ कोडिंग कर सकें।
अगले अध्याय से, हम मूल भाग “सूची क्या है?” को चरणबद्ध तरीके से समझाने से शुरू करेंगे।
2. सूची क्या है?
सूची का अवलोकन और विशेषताएं
जावा में “सूची” एक संग्रह इंटरफेस है जो तत्वों को एक क्रमबद्ध अनुक्रम में रखती है। इसकी सबसे बड़ी विशेषताएं हैं कि तत्व जोड़ने का क्रम संरक्षित रहता है और व्यक्तिगत तत्वों को इंडेक्स (0 से शुरू) का उपयोग करके एक्सेस किया जा सकता है।
सूची को संग्रह फ्रेमवर्क का हिस्सा प्रदान किया गया है और इसमें निम्नलिखित विशेषताएं हैं:
- डुप्लिकेट तत्वों की अनुमति देता है
- इंडेक्स निर्दिष्ट करके तत्वों को प्राप्त, अपडेट और हटा सकता है
- तत्वों की संख्या को गतिशील रूप से बढ़ा या घटा सकता है (सरणियों के विपरीत, यह निश्चित आकार की नहीं है)
इससे लचीला डेटा हेरफेर संभव होता है और यह व्यावहारिक कार्य में बहुत बार उपयोग की जाती है।
सरणी से अंतर
जावा में, सरणियां (जैसे int[] या String[]) भी कई मानों को रखने का एक साधन के रूप में मौजूद हैं, लेकिन सूची से कई अंतर हैं।
| Comparison Item | Array | List |
|---|---|---|
| Changing number of elements | Not possible (fixed-size) | Possible (can increase/decrease dynamically) |
| Provided functionality | Minimal operations (indexed access, length retrieval) | Rich methods (add, remove, contains, etc.) |
| Type | Can handle primitive types | Object types only (wrapper classes required) |
| Type safety | Arrays checked at compile time | Can strictly specify type with Generics |
इस प्रकार, सूची एक अधिक लचीली और सुविधा-समृद्ध संग्रह है, जिससे यह कई स्थितियों में सरणियों की तुलना में अधिक व्यावहारिक हो जाती है।
सूची इंटरफेस और उसके कार्यान्वयन कक्षाएं
जावा में सूची का उपयोग करते समय, आप सामान्यतः सूची इंटरफेस का उपयोग करके एक चर घोषित करते हैं और एक विशिष्ट कक्षा (कार्यान्वयन कक्षा) के साथ एक इंस्टेंस बनाते हैं। प्रतिनिधि कार्यान्वयन कक्षाएं निम्नलिखित हैं:
- सरणी सूची सरणी के समान संरचना, तेज एक्सेस की अनुमति देती है। डेटा खोजने और रैंडम एक्सेस के लिए मजबूत।
- लिंक्ड सूची डबल लिंक्ड सूची संरचना के साथ कार्यान्वित। इन्सर्शन और डिलीशन के लिए तेज, उन सूचियों के लिए उपयुक्त जहां संचालन बार-बार होते हैं।
- वेक्टर सरणी सूची के समान लेकिन थ्रेड-सेफ होने के कारण थोड़ा भारी। आजकल ज्यादा उपयोग नहीं होता।
सामान्यतः, सरणी सूची सबसे अधिक उपयोग की जाती है जब तक कोई विशेष कारण न हो। उपयोग के मामले के आधार पर बाद में वर्णित प्रदर्शन तुलना के आधार पर उपयुक्त का चयन करना अच्छा है।
3. सूची का मूल उपयोग
यह खंड जावा में सूची का उपयोग करते समय मूल संचालनों को चरणबद्ध तरीके से समझाता है। यहां, हम मुख्य रूप से सरणी सूची का उदाहरण लेकर सूची के प्रतिनिधि संचालनों को पेश करेंगे।
सूची की घोषणा और प्रारंभिकरण
सबसे पहले, सरणी सूची का उपयोग करके सूची की मूल घोषणा और प्रारंभिकरण पर नजर डालते हैं।
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");
}
सारांश: अक्सर उपयोग किए जाने वाले मूलभूत ऑपरेशनों की सूची
| Operation | Method Example | Description |
|---|---|---|
| Addition | add("element") | Adds to the end |
| Retrieval | get(index) | References an element |
| Update | set(index, new element) | Changes the element at the specified position |
| Removal | remove(index/element) | Removes the specified element |
| Get Size | size() | Gets the number of elements |
| Check Existence | contains("element") | Checks if a specific element exists |
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 और lambda अभिव्यक्तियों के साथ इस सिंटैक्स का उपयोग भी कर सकते हैं।
fruits.stream().forEach(fruit -> System.out.println(fruit));
इस नोटेशन की ताकत यह है कि कई प्रक्रियाओं को एक साथ चेन किया जा सकता है। उदाहरण के लिए, आप आसानी से फ़िल्टर कर सकते हैं और फिर विशिष्ट मानदंडों के आधार पर तत्वों को प्रिंट कर सकते हैं।
fruits.stream()
.filter(fruit -> fruit.contains("a"))
.forEach(System.out::println);
इस उदाहरण में, यह केवल उन फलों को प्रिंट करता है जिनमें “a” शामिल है। यह उन लोगों के लिए विशेष रूप से अनुशंसित है जो फ़ंक्शनल शैली कोडिंग के आदी होना चाहते हैं।
सही विधि चुनना
| Method | Advantages | Suitable Situations |
|---|---|---|
| Regular for loop | Allows index control | Processing that requires element numbers |
| Enhanced for loop | Simple and easy to read syntax | Simple iteration processing |
| Stream API | Strong for conditional and chained processing | When combining filtering, mapping, and reduction |
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 से थोड़ा अधिक है
उपयुक्त स्थितियाँ:
- ऐसी स्थितियाँ जहाँ तत्व अक्सर डाले या हटाए जाते हैं (विशेषकर शुरुआत या मध्य में)
- जब आप इसे क्यू या स्टैक की तरह उपयोग करना चाहते हैं
- जब इटरेशन पर ध्यान हो और इंडेक्स एक्सेस की आवश्यकता न हो
List<String> list = new LinkedList<>();
प्रदर्शन तुलना
निम्न तालिका सामान्यतः उपयोग किए जाने वाले ऑपरेशनों के लिए सैद्धांतिक समय जटिलता (Big O नोटेशन) दर्शाती है।
| Operation | ArrayList | LinkedList |
|---|---|---|
get(int index) | O(1) | O(n) |
add(E e) (at the end) | O(1) | O(1) |
add(int index, E e) | O(n) | O(n) |
remove(int index) | O(n) | O(n) |
| Iteration | O(n) | O(n) |
* वास्तविक प्रोसेसिंग समय डेटा आकार, JVM अनुकूलन आदि से भी प्रभावित हो सकता है।
व्यावहारिक उपयोग अंतर के बिंदु
- यदि आप डेटा को सूची के रूप में मानते हैं और इंडेक्स द्वारा पहुँचते हैं, तो ArrayList उपयोग करें
- यदि शुरुआत या मध्य में सम्मिलन/विलोपन बार‑बार होता है, तो LinkedList उपयोग करें
- प्रदर्शन‑संवेदनशील प्रोसेसिंग के लिए, हमेशा बेंचमार्क और सत्यापित करें
6. List का उन्नत उपयोग
यहाँ हम जावा की 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() डेटा फ़ॉर्मेट परिवर्तन और प्री‑प्रोसेसिंग के लिए एक शक्तिशाली उपकरण है।
उन्नत ऑपरेशनों का सारांश
| Operation | Usage Example | Main Use Cases |
|---|---|---|
| Sort | Collections.sort(list) | Sort in ascending order |
| Shuffle | Collections.shuffle(list) | Randomize the order of elements |
| Filter | stream().filter(...).collect() | Extract only elements that match a condition |
| Transform | stream().map(...).collect() | Transform the type or value of elements |
7. सामान्य त्रुटियाँ और उनके समाधान
जावा में 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
कारण:
जब for-each लूप या Iterator का उपयोग करके इटररेट करते समय List को सीधे संशोधित किया जाता है।
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 है”।
त्रुटि निवारण सारांश
| Error Name | Primary Cause | Example Solutions |
|---|---|---|
| IndexOutOfBoundsException | Accessing a non-existent index | Check length with size() |
| NullPointerException | List or element is null | Don’t forget initialization, perform null checks |
| ConcurrentModificationException | Directly modifying the List during iteration | Operate with Iterator or utilize removeIf() |
8. निष्कर्ष
जावा List की मूल बातें की समीक्षा
इस लेख में हमने क्रमशः List के बुनियादी से उन्नत पहलुओं को समझाया है। List जावा कलेक्शन्स में विशेष रूप से अक्सर उपयोग किया जाता है और यह डेटा को लचीले ढंग से संभालने के लिए एक महत्वपूर्ण उपकरण है।
पहले, यह समझने के बाद कि List क्या है, हमने निम्नलिखित बिंदु सीखे हैं:
- List एक क्रमबद्ध संग्रह है जो डुप्लिकेट की अनुमति देता है और इंडेक्स ऑपरेशन्स को सपोर्ट करता है
- ArrayList और LinkedList जैसी प्रतिनिधि इम्प्लीमेंटेशन क्लासेज़ हैं, प्रत्येक की अलग विशेषताएँ और उपयोग केस हैं
- बुनियादी ऑपरेशन्स (add, get, update, remove, search) में महारत हासिल करने से डेटा को लचीले ढंग से मैनीपुलेट किया जा सकता है
- स्थिति के अनुसार उपयुक्त इटरेटिव प्रोसेसिंग, जैसे for लूप, एन्हांस्ड for लूप, और Stream API
- सॉर्टिंग, फ़िल्टरिंग, और ट्रांसफ़ॉर्मेशन जैसी उन्नत ऑपरेशन्स को सपोर्ट करता है
- सामान्य त्रुटियों, उनके कारणों और समाधान को समझना समस्याओं को रोकने में मदद करता है
ArrayList और LinkedList उपयोग में अंतर
कौन सा List इम्प्लीमेंटेशन उपयोग करना है, यह चुनना महत्वपूर्ण है और इसे प्रोसेसिंग की सामग्री और डेटा की मात्रा के आधार पर तय किया जाना चाहिए। निम्नलिखित मानदंड मार्गदर्शन के रूप में काम कर सकते हैं:
- ArrayList : अक्सर रैंडम एक्सेस, मुख्यतः पढ़ना
- LinkedList : अक्सर इन्सर्शन/डिलीशन, एक्सेस का क्रम महत्वपूर्ण
भविष्य के सीखने की दिशा
List केवल जावा कलेक्शन्स का “एंट्री पॉइंट” है। अधिक उन्नत डेटा स्ट्रक्चर और यूटिलिटीज़ को संभालने के लिए, निम्नलिखित क्लासेज़ और फीचर्स की समझ को गहरा करने की सलाह दी जाती है:
- Set और Map : यूनिक एलिमेंट्स का प्रबंधन, की-वैल्यू पेयर संरचना
- Collections यूटिलिटी क्लास : सॉर्टिंग, मिन/मैक्स खोज आदि
- Stream API का उपयोग : फंक्शनल प्रोग्रामिंग का परिचय
- Generics को समझना : टाइप-सेफ कलेक्शन ऑपरेशन्स
List की बुनियादी समझ में महारत हासिल करने से आपका समग्र जावा प्रोग्रामिंग काफी आसान और प्रबंधनीय हो जाएगा।
अक्सर पूछे जाने वाले प्रश्न (FAQ)
हमने उन बिंदुओं को संकलित किया है जिनके बारे में शुरुआती अक्सर जावा की List के संबंध में प्रश्न रखते हैं। हमने प्रैक्टिस में अक्सर मिलने वाली सामग्री का चयन किया है।
Q1. जावा की List और Array में क्या अंतर है?
A. एक array में तत्वों की संख्या स्थिर होती है और इसका आकार घोषणा के समय निर्धारित करना पड़ता है। दूसरी ओर, List का आकार परिवर्तनीय होता है, जिससे तत्वों को लचीले ढंग से जोड़ा और हटाया जा सकता है। इसके अलावा, List में कई सुविधाजनक मेथड्स (add, remove, contains, आदि) होते हैं और यह पठनीयता और रखरखाव के मामले में बेहतर है।
Q2. मुझे ArrayList या LinkedList में से कौन सा उपयोग करना चाहिए?
A. ArrayList मुख्यतः तब उपयुक्त है जब बार-बार रैंडम एक्सेस (इंडेक्स द्वारा पुनर्प्राप्ति) की आवश्यकता हो। LinkedList तब उपयुक्त है जब तत्वों का सम्मिलन और विलोपन अक्सर होता हो। यदि संदेह हो, तो सामान्यतः ArrayList से शुरू करना अनुशंसित है।
Q3. क्या मैं List में primitive प्रकार (जैसे int या double) रख सकता हूँ?
A. सीधे नहीं। चूँकि जावा की List केवल ऑब्जेक्ट प्रकारों को संभालती है, इसलिए primitive प्रकारों जैसे int के लिए आपको उनके संबंधित wrapper क्लासेस (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 (आकार प्राप्त करना)। इनको महारत हासिल करने से अधिकांश बुनियादी प्रोसेसिंग कवर हो जाएगी।
