कार्ल की भाषाएँ

जेनेरिक टाइप

एक जेनेरिक टाइप ऐसा जेनेरिक क्लास या इंटरफ़ेस होता है जिसमें टाइपों को पैरामीटर के रूप में दिया जाता है। इससे कंपाइलर उस क्लास या इंटरफ़ेस पर टाइप सेफ्टी लागू कर पाता है।

इस गैर-जेनेरिक Container इंटरफ़ेस को देखिए:

class Container {
    private Object object;

    public void set(Object object) { this.object = object; }
    public Object get() { return object; }
}

चूँकि यह ऑब्जेक्ट टाइप लेता है और लौटाता है, यह किसी भी नॉन-प्रिमिटिव टाइप के साथ काम करता है। लेकिन इसकी एक कीमत चुकानी पड़ती है, क्योंकि हो सकता है कुछ कोड get को कॉल करते समय Integer की उम्मीद करे, जबकि कोई और कोड set को कॉल करके String जोड़ रहा हो। नतीजा यह होता है कि रनटाइम एक्सेप्शन मिलती है।

एक जेनेरिक क्लास और जेनेरिक इंटरफ़ेस का रूप इस तरह होता है:

class ClassName<T1, T2, ..., Tn> { ... }
interface InterfaceName<T1, T2, ..., Tn> { ... }

क्लास या इंटरफ़ेस के नाम के बाद एंगल ब्रैकेट (<>) में लिखा गया टाइप पैरामीटर वाला हिस्सा उन टाइप पैरामीटरों को बताता है, जिन्हें टाइप वेरिएबल भी कहा जाता है: T1, T2, ..., और Tn. इनका उपयोग क्लास या इंटरफ़ेस के भीतर किया जा सकता है, जिससे जेनेरिक टाइप सेफ्टी मिलती है।

यह Container का जेनेरिक रूप है:

class Container<E> {
    private E object;

    public void set(E object) { this.object = object; }
    public E get() { return object; }
}

अब इसे बनाते समय हमें घोषित करना पड़ता है कि यह किस टाइप की वैल्यू रखेगा, और कंपाइलर उस शर्त को लागू करता है:

// empty <> can infer from context
Container<String> stringContainer = new Container<>();
// compiler knows this is a String, so it is allowed
stringContainer.set("Some string");
// no cast needed, compiler knows it is a String
String result = stringContainer.get();
// this causes a compiler error:
stringContainer.set(42);

Lists

List जावा का क्रमबद्ध संग्रह है। ऐरे के विपरीत, एक List अपना आकार बढ़ा सकता है, ताकि वह कितने भी एलिमेंट रख सके। एक मानक इम्प्लीमेंटेशन ArrayList है, जिसके पीछे एक ऐसा ऐरे होता है जिसका आकार बदला जा सकता है। दूसरा मानक इम्प्लीमेंटेशन LinkedList क्लास है, जिसके पीछे एक डबली-लिंक्ड लिस्ट होती है।

List खाली हो सकता है, या उसमें कितने भी एलिमेंट हो सकते हैं (डुप्लिकेट सहित)। List एक जेनेरिक इंटरफ़ेस है, और उसका टाइप बताता है कि वह किस टाइप के ऑब्जेक्ट रख सकता है। उदाहरण के लिए:

List<String> emptyListOfStrings = List.of();
List<Integer> singleInteger = List.of(1);
List<Boolean> threeBooleans = List.of(true, false, true);
List<Object> listWithMultipleTypes = List.of("hello", 1, true);

List में एलिमेंट जोड़ने, हटाने, निकालने और यह जाँचने के लिए कई उपयोगी मेथड होते हैं कि कोई एलिमेंट मौजूद है या नहीं:

List<Character> vowels = new ArrayList<>(List.of('a', 'e', 'i', 'o', 'i', 'e', 'a'));
int startingSize = vowels.size(); // 7
vowels.add('u'); // vowels is now ['a', 'e', 'i', 'o', 'i', 'e', 'a', 'u']
char a = vowels.get(0); // 'a'
boolean hadI = vowels.remove('i'); // true and vowels is now ['a', 'e', 'o', 'i', 'e', 'a', 'u']
boolean hasI = vowels.contains('i'); // true (still have one more left)