लिस्ट्स

Java में डेटा टाइप्स और Exceptions

Jim White

Java Developer

List इंटरफ़ेस

List इंटरफ़ेस, Collection का सब-इंटरफ़ेस
- ऑब्जेक्ट्स का एक क्रमबद्ध समूह परिभाषित करता है
- डुप्लिकेट ऑब्जेक्ट्स रख सकता है
List की कई implementations
- व्यवहार में सभी समान
- Implementation तय करती है कि अंदरूनी स्तर पर ऑब्जेक्ट्स कैसे मैनेज होते हैं

List implementations

ArrayList - resizable, indexed (arrays जैसा), ordered ऑब्जेक्ट list

ArrayList Java arrays जैसी होती हैं जिनमें indexed elements होते हैं

LinkedList - ऑब्जेक्ट्स next और previous लिंक से जुड़े होते हैं.

LinkedList pointers से जुड़ी ऑब्जेक्ट लिस्ट होती है

Implementation कोई भी हो, add, remove, change एक ही तरह से करें

¹ See https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/util/List.html for List types and details

ArrayList

new से instance बनाएँ और generics से content type बताइए
list के अंत में ऑब्जेक्ट जोड़ें: .add(object)
किसी ऑब्जेक्ट को पाएँ: .get(index)
- ArrayList का index zero-based होता है
ऑब्जेक्ट बदलें: .set(index, object)
ऑब्जेक्ट हटाएँ: .remove(index)
सभी ऑब्जेक्ट्स साफ करें: .clear()
ऑब्जेक्ट्स की गिनती: .size()

import java.util.ArrayList;
...
ArrayList<String> animals
  = new ArrayList<String>();

animals.add("horse");
animals.add("cow");
animals.add("horse"); // Duplicates allowed

String c = animals.get(1); // c="cow"
animals.set(1, "chicken");

// Removes the first horse
animals.remove(0);  
// Removes all objects
animals.clear();

animals.size();

Objects और primitives

किसी भी Collections Framework ऑब्जेक्ट में primitive जोड़ने के लिए wrappers का उपयोग करें
जोड़े गए primitives "autoboxed" होते हैं
- Autobox: primitive को wrapper में अपने-आप रखना

ArrayList<Integer> list = new ArrayList<Integer>();
list.add(new Integer(5));
list.add(6);  // 6 अपने-आप Integer में wrap होकर add होता है

Autoboxing सभी Collections Framework ऑब्जेक्ट्स में काम करता है

Heterogeneous collections

Collections Framework data structures heterogenous हो सकते हैं
- Heterogenous = अलग-अलग टाइप के ऑब्जेक्ट्स रख सकते हैं
- Object को parameterized type की तरह उपयोग करें

ArrayList<Object> list = new ArrayList<Object>(); // कोई भी object allow
list.add(new Integer(5)); // एक Integer जोड़ें
list.add(6); // autoboxing से Integer जोड़ें
list.add("Hello"); // एक String जोड़ें

List पर loop

List के ऑब्जेक्ट्स पर loop करने के लिए "for each" सिंटैक्स उपयोग करें

ArrayList<String> animals = new ArrayList<String>();
animals.add("horse");
animals.add("cow");
animals.add("chicken");

for (String animal : animals) { // for-each से ArrayList के सभी पर loop
    System.out.println(animal);
}

horse
cow
chicken

List println

List instance (जैसे ArrayList) की सामग्री println से दिखाई जा सकती है

ArrayList<String> animals = new ArrayList<String>();
animals.add("horse");
animals.add("cow");
animals.add("chicken");
System.out.println(animals);  // ArrayList के सभी elements दिखाएँ

ArrayList<Object> list = new ArrayList<Object>();
list.add(5);
list.add("Hello");
System.out.println(list);  // ArrayList के सभी elements दिखाएँ

[horse, cow, chicken]
[5, Hello]

LinkedList

LinkedList को ArrayList की तरह ही construct किया जाता है
LinkedList में ArrayList जैसी ही methods होती हैं

import java.util.LinkedList;
...
LinkedList<String> cars // Create a new ...
  = new LinkedList<String>(); // ... LinkedList

cars.add("Ford"); // Add an object to the list
cars.add("Mercedes");
String c = cars.get(1);
cars.set(1, "Toyota"); // Replace an object
System.out.println(cars); // Display the list
cars.remove(0); // Remove an object
cars.clear();  // Remove all objects
cars.size(); // Get the list length

[Ford, Toyota]

LinkedList की अतिरिक्त methods

कुछ अतिरिक्त methods
- addFirst() list की शुरुआत में जोड़ें
- addLast() list के अंत में जोड़ें
- removeFirst() शुरुआत से हटाएँ
- removeLast() अंत से हटाएँ

cars.addFirst("Fiat"); // शुरुआत में जोड़ें
cars.addLast("BMW"); // अंत में जोड़ें
cars.removeFirst(); // पहला ऑब्जेक्ट हटाएँ
cars.removeLast(); // आखिरी ऑब्जेक्ट हटाएँ

Collection टाइप समानताएँ

ArrayList और LinkedList एक जैसे दिखते हैं
- Collections Framework के दूसरे टाइप्स में भी समानताएँ होंगी
- यह जानबूझकर है
वे एक इंटरफ़ेस साझा करते हैं: List
- polymorphism ("many-forms") का उदाहरण

ArrayList बनाम LinkedList

ArrayList और LinkedList (या कोई भी List) पर operations समान होते हैं
- कौन-सा List लें, यह उपयोग पर निर्भर है
ArrayList के लिए विचार:
- random access तेज (जैसे: list.get(11))
- बीच में add/remove धीमा
- क्योंकि insert/remove पर ऑब्जेक्ट्स को शारीरिक रूप से खिसकाना पड़ता है

ArrayList के बीच में जोड़ने पर बहुत मूविंग करनी पड़ती है

ArrayList बनाम LinkedList

LinkedList के लिए विचार:
- random access धीमा (जैसे: list.get(11))
- बीच में add/remove तेज
- क्योंकि कोई ऑब्जेक्ट वास्तव में नहीं खिसकते, बस कुछ references बदलते हैं

LinkedList के बीच में जोड़ने पर केवल कुछ pointers बदलने पड़ते हैं

अभ्यास करते हैं!

Java में डेटा टाइप्स और Exceptions