S11L10 - जावा कलेक्शंस फ्रेमवर्क में TreeMap

html

Java Collections में TreeMap में महारत हासिल करना: एक व्यापक मार्गदर्शिका
सामग्री तालिका

परिचय ............................................. 1
TreeMap बनाम HashMap को समझना ... 3
Java में TreeMap को लागू करना .......... 7
TreeMap में कस्टम ऑब्जेक्ट्स के साथ काम करना .............................................. 12
Comparable इंटरफ़ेस को लागू करना .................................................................................. 18
सामान्य गलतियां और सर्वोत्तम अभ्यास ................................................................. 25
निष्कर्ष ..................................................... 30


परिचय
Java Collections में TreeMap में महारत हासिल करना: एक व्यापक मार्गदर्शिका में आपका स्वागत है। Java प्रोग्रामिंग के क्षेत्र में, विभिन्न collection frameworks को समझना कुशल डेटा प्रबंधन और हेरफेर के लिए महत्वपूर्ण है। यह eBook Java के Collections Framework के भीतर TreeMap क्लास में गहराई से उतरता है, इसकी कार्यक्षमताओं, लाभों और व्यावहारिक कार्यान्वयन का अन्वेषण करता है।
चाहे आप एक शुरुआतकर्ता हों जो अपनी Java यात्रा प्रारंभ कर रहे हैं या एक अनुभवी डेवलपर हों जो अपने कौशल को परिष्कृत करना चाहते हैं, यह मार्गदर्शिका TreeMap के उपयोग को अनुकूलित करने में मूल्यवान अंतर्दृष्टि प्रदान करती है। हम प्रमुख अवधारणाओं का अन्वेषण करेंगे, TreeMap की तुलना अन्य collections जैसे HashMap से करेंगे, और व्यावहारिक कोड उदाहरणों से परिपूर्ण विस्तृत व्याख्याएँ प्रदान करेंगे।

TreeMap बनाम HashMap को समझना
समीक्षा
Java के Collections Framework में, दोनों TreeMap और HashMap Map इंटरफ़ेस के कार्यान्वयन हैं, जो कुंजी-मूल्य जोड़ों को संग्रहीत करने के लिए डिज़ाइन किए गए हैं। हालांकि, वे अपने अंतर्निहित तंत्रों, प्रदर्शन विशेषताओं और उपयोग के मामलों में काफी भिन्न हैं।
प्रमुख अंतर


विशेषता
TreeMap
HashMap


क्रमबद्धता
कुंजी के प्राकृतिक क्रम या एक कस्टम Comparator के आधार पर सॉर्टेड
कोई गारंटीकृत क्रम नहीं


प्रदर्शन
put, get, remove संचालन के लिए O(log n) समय
put, get, remove संचालन के लिए O(1) समय (औसत मामला)


Null Keys
शून्य कुंजी की अनुमति नहीं देता
एक शून्य कुंजी की अनुमति देता है


उपयोग परिदृश्य
जब क्रमबद्ध क्रम आवश्यक हो या सीमा-आधारित संचालन की आवश्यकता हो
जब बिना क्रम बाधाओं के तेज पहुँच आवश्यक हो


TreeMap का उपयोग कब करें

सॉर्टेड डेटा: यदि आपका अनुप्रयोग डेटा को एक विशिष्ट क्रम में बनाए रखने की आवश्यकता है, विशेष रूप से कुंजी द्वारा क्रमबद्ध।
रेंज क्वेरीज़: जब आपको सीमा-आधारित संचालन करने की आवश्यकता हो, जैसे कि एक निश्चित सीमा के भीतर सभी प्रविष्टियों को पुनः प्राप्त करना।
Navigable Features: TreeMap अतिरिक्त नेविगेबल विधियाँ प्रदान करता है जैसे ceilingKey, floorKey, firstKey, और lastKey जो विशिष्ट संचालन के लिए लाभकारी हैं।

फायदे और नुकसान
TreeMap
फायदे:

कुंजी के क्रम में सॉर्टेड क्रम बनाए रखता है।
सीमा और सबसे करीबी कुंजी क्वेरी के लिए नेविगेबल विधियाँ प्रदान करता है।
क्रमबद्ध ट्रैवर्सल की आवश्यकता वाले परिदृश्यों के लिए कुशल।

नुकसान:

अपने अंतर्निहित रेड-ब्लैक ट्री ढांचे के कारण बुनियादी संचालन के लिए HashMap की तुलना में धीमा प्रदर्शन।
शून्य कुंजी की अनुमति नहीं देता, जो कुछ परिदृश्यों में प्रतिबंधकारी हो सकता है।

HashMap
फायदे:

औसत मामले में स्थिर-समय जटिलता के साथ तेज संचालन।
एक शून्य कुंजी और कई शून्य मानों की अनुमति देता है।
बड़ी डेटा सेट्स के लिए उपयुक्त जहाँ प्रदर्शन प्राथमिकता है।

नुकसान:

प्रविष्टियों का कोई अंतर्निहित क्रम नहीं।
क्रमबद्ध डेटा या सीमा क्वेरियों की आवश्यकता वाले परिदृश्यों के लिए उपयुक्त नहीं।

तालिकीय तुलना


पहलू
TreeMap
HashMap


कार्यान्वयन
रेड-ब्लैक ट्री
हैश टेबल


समय जटिलता
put, get, remove के लिए O(log n)
put, get, remove के लिए O(1) (औसत मामला)


क्रमबद्धता
कुंजी द्वारा सॉर्टेड
कोई क्रम नहीं


Null Keys
अनुमत नहीं
एक शून्य कुंजी अनुमति है


मेमोरी ओवरहेड
ट्री संरचना के कारण अधिक
कम



Java में TreeMap को लागू करना
TreeMap के साथ शुरुआत करना
अपने Java अनुप्रयोगों में TreeMap का उपयोग करने के लिए, आपको संबंधित क्लास को आयात करने और इसके बुनियादी संचालन को समझने की आवश्यकता है। नीचे TreeMap को लागू करने के लिए चरण-दर-चरण मार्गदर्शिका दी गई है।
बुनियादी संचालन

TreeMap आयात करना:





		
		
			
			
Java
			
			import java.util.TreeMap;

			
				
					
				
					1
2
				
						import java.util.TreeMap;
 
					
				
			
		



TreeMap इंस्टेंस बनाना:





		
		
			
			
Java
			
			TreeMap&lt;String, String&gt; treeMap = new TreeMap&lt;&gt;();

			
				
					
				
					1
2
				
						TreeMap&lt;String, String&gt; treeMap = new TreeMap&lt;&gt;();
 
					
				
			
		



प्रविष्टियाँ जोड़ना:





		
		
			
			
Java
			
			treeMap.put("A1", "Afia");
treeMap.put("A2", "Alex");
treeMap.put("A2", "Rahul"); // यह कुंजी "A2" के लिए मान को प्रतिस्थापित करेगा

			
				
					
				
					1
2
3
4
				
						treeMap.put("A1", "Afia");
treeMap.put("A2", "Alex");
treeMap.put("A2", "Rahul"); // यह कुंजी "A2" के लिए मान को प्रतिस्थापित करेगा
 
					
				
			
		



प्रविष्टियाँ प्राप्त करना:





		
		
			
			
Java
			
			String value = treeMap.get("A2"); // "Rahul" लौटाता है

			
				
					
				
					1
2
				
						String value = treeMap.get("A2"); // "Rahul" लौटाता है
 
					
				
			
		



प्रविष्टियों पर पुनरावृत्ति करना:





		
		
			
			
Java
			
			for (Map.Entry&lt;String, String&gt; entry : treeMap.entrySet()) {
    System.out.println(entry.getKey() + " : " + entry.getValue());
}

			
				
					
				
					1
2
3
4
				
						for (Map.Entry&lt;String, String&gt; entry : treeMap.entrySet()) {
    System.out.println(entry.getKey() + " : " + entry.getValue());
}
 
					
				
			
		


प्रदर्शन
निम्न उदाहरण पर विचार करें जो TreeMap के व्यवहार को HashMap की तुलना में उजागर करता है:




		
		
			
			
Java
			
			import java.util.HashMap;
import java.util.TreeMap;

public class Main {
    public static void main(String[] args) {
        // HashMap का उपयोग करना
        HashMap&lt;String, String&gt; hashMap = new HashMap&lt;&gt;();
        hashMap.put("A2", "Alex");
        hashMap.put("A2", "Rahul");
        System.out.println("HashMap Output:");
        hashMap.forEach((key, value) -&gt; System.out.println(key + " : " + value));

        // TreeMap का उपयोग करना
        TreeMap&lt;String, String&gt; treeMap = new TreeMap&lt;&gt;();
        treeMap.put("A0", "Afia");
        treeMap.put("A1", "Bob");
        treeMap.put("A2", "Alex");
        treeMap.put("A2", "Rahul");
        System.out.println("\nTreeMap Output:");
        treeMap.forEach((key, value) -&gt; System.out.println(key + " : " + value));
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
				
						import java.util.HashMap;
import java.util.TreeMap;
 
public class Main {
    public static void main(String[] args) {
        // HashMap का उपयोग करना
        HashMap&lt;String, String&gt; hashMap = new HashMap&lt;&gt;();
        hashMap.put("A2", "Alex");
        hashMap.put("A2", "Rahul");
        System.out.println("HashMap Output:");
        hashMap.forEach((key, value) -&gt; System.out.println(key + " : " + value));
 
        // TreeMap का उपयोग करना
        TreeMap&lt;String, String&gt; treeMap = new TreeMap&lt;&gt;();
        treeMap.put("A0", "Afia");
        treeMap.put("A1", "Bob");
        treeMap.put("A2", "Alex");
        treeMap.put("A2", "Rahul");
        System.out.println("\nTreeMap Output:");
        treeMap.forEach((key, value) -&gt; System.out.println(key + " : " + value));
    }
}
 
					
				
			
		


आउटपुट:




		
		
			
			
Java
			
			HashMap Output:
A2 : Rahul

TreeMap Output:
A0 : Afia
A1 : Bob
A2 : Rahul

			
				
					
				
					1
2
3
4
5
6
7
8
				
						HashMap Output:
A2 : Rahul
 
TreeMap Output:
A0 : Afia
A1 : Bob
A2 : Rahul
 
					
				
			
		


व्याख्या

HashMap में, डुप्लीकेट कुंजी "A2" जोड़ने पर मौजूदा मान प्रतिस्थापित हो जाता है, जिसके परिणामस्वरूप केवल एक प्रविष्टि "A2" कुंजी और "Rahul" मान के साथ रहती है।
TreeMap में, प्रविष्टियाँ कुंजी द्वारा क्रमबद्ध होती हैं। डुप्लीकेट कुंजी "A2" होने पर भी, नवीनतम मान पिछले को प्रतिस्थापित कर देता है, जिससे क्रमबद्ध क्रम बना रहता है।

दृश्यात्मक प्रतिनिधित्व

चित्र 1: TreeMap और HashMap डेटा संरचनाओं के बीच तुलना।

TreeMap में कस्टम ऑब्जेक्ट्स के साथ काम करना
कस्टम ऑब्जेक्ट्स की चुनौती
जब TreeMap में कुंजी के रूप में कस्टम ऑब्जेक्ट्स का उपयोग किया जाता है, तो यह सुनिश्चित करना आवश्यक है कि TreeMap इन ऑब्जेक्ट्स को सही ढंग से सॉर्ट और व्यवस्थित कर सके। प्रिमिटिव प्रकारों या मानक रैपर क्लासेज़ के विपरीत, कस्टम ऑब्जेक्ट्स को स्वयं की तुलना करने के लिए स्पष्ट निर्देशों की आवश्यकता होती है।
व्रैपर क्लास बनाना
आइए एक कस्टम Code क्लास बनाते हैं जो हमारे TreeMap में कुंजी के रूप में उपयोग किया जाएगा।




		
		
			
			
Java
			
			public class Code implements Comparable&lt;Code&gt; {
    private int lectureNumber;
    private int sectionNumber;

    // Constructor
    public Code(int lectureNumber, int sectionNumber) {
        this.lectureNumber = lectureNumber;
        this.sectionNumber = sectionNumber;
    }

    // Getters
    public int getLectureNumber() {
        return lectureNumber;
    }

    public int getSectionNumber() {
        return sectionNumber;
    }

    // toString method for readability
    @Override
    public String toString() {
        return "Code(" + lectureNumber + ", " + sectionNumber + ")";
    }

    // compareTo method to define natural ordering
    @Override
    public int compareTo(Code other) {
        if (this.lectureNumber != other.lectureNumber) {
            return Integer.compare(this.lectureNumber, other.lectureNumber);
        } else {
            return Integer.compare(this.sectionNumber, other.sectionNumber);
        }
    }

    // equals and hashCode methods (optional but recommended)
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (!(obj instanceof Code)) return false;
        Code other = (Code) obj;
        return this.lectureNumber == other.lectureNumber && this.sectionNumber == other.sectionNumber;
    }

    @Override
    public int hashCode() {
        return Objects.hash(lectureNumber, sectionNumber);
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
				
						public class Code implements Comparable&lt;Code&gt; {
    private int lectureNumber;
    private int sectionNumber;
 
    // Constructor
    public Code(int lectureNumber, int sectionNumber) {
        this.lectureNumber = lectureNumber;
        this.sectionNumber = sectionNumber;
    }
 
    // Getters
    public int getLectureNumber() {
        return lectureNumber;
    }
 
    public int getSectionNumber() {
        return sectionNumber;
    }
 
    // toString method for readability
    @Override
    public String toString() {
        return "Code(" + lectureNumber + ", " + sectionNumber + ")";
    }
 
    // compareTo method to define natural ordering
    @Override
    public int compareTo(Code other) {
        if (this.lectureNumber != other.lectureNumber) {
            return Integer.compare(this.lectureNumber, other.lectureNumber);
        } else {
            return Integer.compare(this.sectionNumber, other.sectionNumber);
        }
    }
 
    // equals and hashCode methods (optional but recommended)
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (!(obj instanceof Code)) return false;
        Code other = (Code) obj;
        return this.lectureNumber == other.lectureNumber && this.sectionNumber == other.sectionNumber;
    }
 
    @Override
    public int hashCode() {
        return Objects.hash(lectureNumber, sectionNumber);
    }
}
 
					
				
			
		


व्रैपर क्लास का व्याख्या

Fields:

lectureNumber: व्याख्यान पहचानकर्ता को प्रदर्शित करता है।
sectionNumber: व्याख्यान के भीतर अनुभाग पहचानकर्ता को प्रदर्शित करता है।


Constructor:

lectureNumber और sectionNumber को प्रारंभ करता है।


Getters:

निजी फ़ील्ड्स तक पहुँच प्रदान करते हैं।


toString Method:

ऑब्जेक्ट्स को प्रिंट करते समय बेहतर पठनीयता के लिए डिफ़ॉल्ट toString विधि को ओवरराइड करता है।


Comparable इंटरफेस कार्यान्वयन:

compareTo विधि Code ऑब्जेक्ट्स के प्राकृतिक क्रम को परिभाषित करती है।
प्राथमिक सॉर्टिंग lectureNumber के आधार पर होती है।
यदि lectureNumber मान समान हैं, तो सॉर्टिंग sectionNumber के आधार पर आगे बढ़ती है।


equals और hashCode Methods:

यह सुनिश्चित करते हैं कि दो Code ऑब्जेक्ट्स जिनके lectureNumber और sectionNumber समान हैं, समान माने जाएं।
ये विधियाँ महत्वपूर्ण होती हैं जब TreeMap संचालन ऑब्जेक्ट की समानता पर निर्भर करते हैं।



TreeMap में कस्टम ऑब्जेक्ट्स का उपयोग करना




		
		
			
			
Java
			
			import java.util.TreeMap;

public class Main {
    public static void main(String[] args) {
        TreeMap&lt;Code, String&gt; treeMap = new TreeMap&lt;&gt;();

        // TreeMap में प्रविष्टियाँ जोड़ना
        treeMap.put(new Code(10, 11), "Section 10 Lecture 11");
        treeMap.put(new Code(10, 10), "Section 10 Lecture 10");
        treeMap.put(new Code(9, 5), "Section 9 Lecture 5");
        treeMap.put(new Code(10, 11), "Updated Section 10 Lecture 11"); // यह पिछली मान को प्रतिस्थापित करेगा

        // TreeMap प्रविष्टियों पर पुनरावृत्ति करना
        treeMap.forEach((key, value) -&gt; System.out.println(key + " : " + value));
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
				
						import java.util.TreeMap;
 
public class Main {
    public static void main(String[] args) {
        TreeMap&lt;Code, String&gt; treeMap = new TreeMap&lt;&gt;();
 
        // TreeMap में प्रविष्टियाँ जोड़ना
        treeMap.put(new Code(10, 11), "Section 10 Lecture 11");
        treeMap.put(new Code(10, 10), "Section 10 Lecture 10");
        treeMap.put(new Code(9, 5), "Section 9 Lecture 5");
        treeMap.put(new Code(10, 11), "Updated Section 10 Lecture 11"); // यह पिछली मान को प्रतिस्थापित करेगा
 
        // TreeMap प्रविष्टियों पर पुनरावृत्ति करना
        treeMap.forEach((key, value) -&gt; System.out.println(key + " : " + value));
    }
}
 
					
				
			
		


आउटपुट:




		
		
			
			
Java
			
			Code(9, 5) : Section 9 Lecture 5
Code(10, 10) : Section 10 Lecture 10
Code(10, 11) : Updated Section 10 Lecture 11

			
				
					
				
					1
2
3
4
				
						Code(9, 5) : Section 9 Lecture 5
Code(10, 10) : Section 10 Lecture 10
Code(10, 11) : Updated Section 10 Lecture 11
 
					
				
			
		


व्याख्या

TreeMap compareTo विधि में परिभाषित प्राकृतिक क्रम के आधार पर Code ऑब्जेक्ट्स को सॉर्ट करता है।
जब एक डुप्लीकेट कुंजी (Code(10, 11)) जोड़ी जाती है, तो नया मान मौजूदा को प्रतिस्थापित कर देता है।
आउटपुट TreeMap में प्रविष्टियों के क्रमबद्ध क्रम को दर्शाता है।

आरेखात्मक प्रतिनिधित्व

चित्र 2: TreeMap जिसमें कस्टम Code ऑब्जेक्ट्स कुंजी के रूप में हैं।

Comparable इंटरफ़ेस को लागू करना
Comparable इंटरफ़ेस को समझना
Java में Comparable इंटरफ़ेस का उपयोग ऑब्जेक्ट्स के प्राकृतिक क्रम को परिभाषित करने के लिए किया जाता है। इस इंटरफ़ेस को लागू करके, आप यह निर्दिष्ट कर सकते हैं कि आपके कस्टम क्लास के ऑब्जेक्ट्स एक-दूसरे की तुलना कैसे करें, जो कि TreeMap जैसे क्रमबद्ध संग्रह के लिए आवश्यक है।
Code क्लास में Comparable को लागू करना
आइए Code क्लास को पुनः देखें और compareTo विधि कार्यान्वयन में और गहराई से उतरें।




		
		
			
			
Java
			
			public class Code implements Comparable&lt;Code&gt; {
    private int lectureNumber;
    private int sectionNumber;

    // Constructor, getters, and other methods remain the same

    @Override
    public int compareTo(Code other) {
        if (this.lectureNumber != other.lectureNumber) {
            return Integer.compare(this.lectureNumber, other.lectureNumber);
        } else {
            return Integer.compare(this.sectionNumber, other.sectionNumber);
        }
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
				
						public class Code implements Comparable&lt;Code&gt; {
    private int lectureNumber;
    private int sectionNumber;
 
    // Constructor, getters, and other methods remain the same
 
    @Override
    public int compareTo(Code other) {
        if (this.lectureNumber != other.lectureNumber) {
            return Integer.compare(this.lectureNumber, other.lectureNumber);
        } else {
            return Integer.compare(this.sectionNumber, other.sectionNumber);
        }
    }
}
 
					
				
			
		


चरण-दर-चरण व्याख्या

विधि हस्ताक्षर:

public int compareTo(Code other): वर्तमान ऑब्जेक्ट की तुलना निर्दिष्ट ऑब्जेक्ट से क्रम के लिए करता है।


प्राथमिक तुलना (lectureNumber):

यदि वर्तमान ऑब्जेक्ट का lectureNumber अन्य ऑब्जेक्ट के lectureNumber से अलग है, तो विधि इन दो पूर्णांकों की तुलना का परिणाम लौटाती है।
Integer.compare निम्नलिखित लौटाता है:

यदि पहला तर्क दूसरा तर्क से कम है तो एक ऋणात्मक पूर्णांक।
यदि वे समान हैं तो शून्य।
यदि पहला तर्क दूसरा तर्क से बड़ा है तो एक धनात्मक पूर्णांक।




द्वितीयक तुलना (sectionNumber):

यदि lectureNumber मान समान हैं, तो विधि sectionNumber की तुलना करना जारी रखती है।
यह सुनिश्चित करता है कि समान lectureNumber वाले ऑब्जेक्ट्स को sectionNumber के आधार पर आगे सॉर्ट किया जाए।



Null मानों को संभालना
प्रारंभिक कार्यान्वयन में, compareTo विधि ने null मानों को ध्यान में नहीं रखा था। संभावित nulls को संभालना आवश्यक है ताकि NullPointerException से बचा जा सके।
संशोधित compareTo विधि:




		
		
			
			
Java
			
			@Override
public int compareTo(Code other) {
    if (other == null) {
        throw new NullPointerException("Cannot compare to null");
    }
    if (this.lectureNumber != other.lectureNumber) {
        return Integer.compare(this.lectureNumber, other.lectureNumber);
    } else {
        return Integer.compare(this.sectionNumber, other.sectionNumber);
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
				
						@Override
public int compareTo(Code other) {
    if (other == null) {
        throw new NullPointerException("Cannot compare to null");
    }
    if (this.lectureNumber != other.lectureNumber) {
        return Integer.compare(this.lectureNumber, other.lectureNumber);
    } else {
        return Integer.compare(this.sectionNumber, other.sectionNumber);
    }
}
 
					
				
			
		


Comparable कार्यान्वयन का परीक्षण करना




		
		
			
			
Java
			
			import java.util.TreeMap;

public class Main {
    public static void main(String[] args) {
        TreeMap&lt;Code, String&gt; treeMap = new TreeMap&lt;&gt;();

        treeMap.put(new Code(12, 1), "Section 12 Lecture 1");
        treeMap.put(new Code(10, 5), "Section 10 Lecture 5");
        treeMap.put(new Code(10, 5), "Updated Section 10 Lecture 5");
        treeMap.put(new Code(11, 3), "Section 11 Lecture 3");

        treeMap.forEach((key, value) -&gt; System.out.println(key + " : " + value));
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
				
						import java.util.TreeMap;
 
public class Main {
    public static void main(String[] args) {
        TreeMap&lt;Code, String&gt; treeMap = new TreeMap&lt;&gt;();
 
        treeMap.put(new Code(12, 1), "Section 12 Lecture 1");
        treeMap.put(new Code(10, 5), "Section 10 Lecture 5");
        treeMap.put(new Code(10, 5), "Updated Section 10 Lecture 5");
        treeMap.put(new Code(11, 3), "Section 11 Lecture 3");
 
        treeMap.forEach((key, value) -&gt; System.out.println(key + " : " + value));
    }
}
 
					
				
			
		


आउटपुट:




		
		
			
			
Java
			
			Code(10, 5) : Updated Section 10 Lecture 5
Code(11, 3) : Section 11 Lecture 3
Code(12, 1) : Section 12 Lecture 1

			
				
					
				
					1
2
3
4
				
						Code(10, 5) : Updated Section 10 Lecture 5
Code(11, 3) : Section 11 Lecture 3
Code(12, 1) : Section 12 Lecture 1
 
					
				
			
		


व्याख्या

compareTo विधि यह सुनिश्चित करती है कि TreeMap में प्रविष्टियाँ पहले lectureNumber द्वारा और फिर sectionNumber द्वारा क्रमबद्ध हों।
जब एक डुप्लीकेट कुंजी (Code(10, 5)) जोड़ी जाती है, तो नया मान मौजूदा को प्रतिस्थापित कर देता है, जैसा कि Map इंटरफ़ेस के अनुबंध में परिभाषित है।


सामान्य गलतियां और सर्वोत्तम अभ्यास
सामान्य गलती 1: Comparable को लागू नहीं करना या Comparator का उपयोग नहीं करना
समस्या: TreeMap में कुंजी के रूप में कस्टम ऑब्जेक्ट्स का उपयोग करते समय अगर Comparable इंटरफ़ेस को लागू नहीं किया गया है या Comparator प्रदान नहीं किया गया है, तो एप्लिकेशन ClassCastException फेंकेगा।
समाधान: हमेशा सुनिश्चित करें कि आपकी कुंजी क्लास Comparable को लागू करती है और compareTo विधि को सही ढंग से ओवरराइड करती है, या TreeMap को प्रारंभ करते समय एक Comparator प्रदान करें।




		
		
			
			
Java
			
			// Comparable का उपयोग करना
TreeMap&lt;Code, String&gt; treeMap = new TreeMap&lt;&gt;();

// Comparator का उपयोग करना
TreeMap&lt;Code, String&gt; treeMapWithComparator = new TreeMap&lt;&gt;(new Comparator&lt;Code&gt;() {
    @Override
    public int compare(Code c1, Code c2) {
        // कस्टम तुलना लॉजिक
    }
});

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
				
						// Comparable का उपयोग करना
TreeMap&lt;Code, String&gt; treeMap = new TreeMap&lt;&gt;();
 
// Comparator का उपयोग करना
TreeMap&lt;Code, String&gt; treeMapWithComparator = new TreeMap&lt;&gt;(new Comparator&lt;Code&gt;() {
    @Override
    public int compare(Code c1, Code c2) {
        // कस्टम तुलना लॉजिक
    }
});
 
					
				
			
		


सामान्य गलती 2: असंगत equals और compareTo विधियाँ
समस्या: यदि equals और compareTo विधियाँ असंगत हैं (अर्थात् compareTo शून्य लौटाता है लेकिन equals false लौटाता है), तो क्रमबद्ध संग्रहों में अप्रत्याशित व्यवहार हो सकता है।
समाधान: सुनिश्चित करें कि यदि compareTo दो ऑब्जेक्ट्स को समान मानता है (शून्य लौटाता है), तो equals विधि भी उन ऑब्जेक्ट्स के लिए true लौटाए।
सामान्य गलती 3: Null मानों को अनदेखा करना
समस्या: TreeMap शून्य कुंजी की अनुमति नहीं देता। एक शून्य कुंजी डालने का प्रयास करने पर NullPointerException उत्पन्न होगा।
समाधान: हमेशा TreeMap में कुंजियाँ डालने से पहले null जांचें।




		
		
			
			
Java
			
			if (key != null) {
    treeMap.put(key, value);
} else {
    // शून्य कुंजी परिदृश्य को संभालें
}

			
				
					
				
					1
2
3
4
5
6
				
						if (key != null) {
    treeMap.put(key, value);
} else {
    // शून्य कुंजी परिदृश्य को संभालें
}
 
					
				
			
		


सर्वोत्तम अभ्यास 1: बेहतर पठनीयता के लिए toString को ओवरराइड करें
अपने कुंजी क्लासेज़ में toString विधि को ओवरराइड करें ताकि TreeMap प्रविष्टियों की पठनीयता को सुधारने में मदद मिले, खासकर डिबगिंग या लॉगिंग के दौरान।




		
		
			
			
Java
			
			@Override
public String toString() {
    return "Code(" + lectureNumber + ", " + sectionNumber + ")";
}

			
				
					
				
					1
2
3
4
5
				
						@Override
public String toString() {
    return "Code(" + lectureNumber + ", " + sectionNumber + ")";
}
 
					
				
			
		


सर्वोत्तम अभ्यास 2: equals और hashCode विधियाँ लागू करें
हालांकि TreeMap मुख्य रूप से क्रमबद्धता के लिए compareTo विधि पर निर्भर करता है, equals और hashCode लागू करने से आपके अनुप्रयोग के विभिन्न हिस्सों और अन्य संग्रहों में जो इन विधियों का उपयोग कर सकते हैं उनकी एकरूपता सुनिश्चित होती है।




		
		
			
			
Java
			
			@Override
public boolean equals(Object obj) {
    if (this == obj) return true;
    if (!(obj instanceof Code)) return false;
    Code other = (Code) obj;
    return this.lectureNumber == other.lectureNumber && this.sectionNumber == other.sectionNumber;
}

@Override
public int hashCode() {
    return Objects.hash(lectureNumber, sectionNumber);
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
				
						@Override
public boolean equals(Object obj) {
    if (this == obj) return true;
    if (!(obj instanceof Code)) return false;
    Code other = (Code) obj;
    return this.lectureNumber == other.lectureNumber && this.sectionNumber == other.sectionNumber;
}
 
@Override
public int hashCode() {
    return Objects.hash(lectureNumber, sectionNumber);
}
 
					
				
			
		


सर्वोत्तम अभ्यास 3: प्रकार सुरक्षा के लिए Generics का उपयोग करें
हमेशा अपने TreeMap को विशिष्ट प्रकारों के साथ पैरामीटराइज़ करें ताकि प्रकार सुरक्षा लागू हो सके और संभावित ClassCastException से बचा जा सके।




		
		
			
			
Java
			
			TreeMap&lt;Code, String&gt; treeMap = new TreeMap&lt;&gt;();

			
				
					
				
					1
2
				
						TreeMap&lt;Code, String&gt; treeMap = new TreeMap&lt;&gt;();
 
					
				
			
		


सर्वोत्तम अभ्यास 4: कुंजियाँ के रूप में परिवर्तनीय ऑब्जेक्ट्स का उपयोग न करें
परिवर्तनीय ऑब्जेक्ट्स का उपयोग कुंजियाँ के रूप में अप्रत्याशित व्यवहार का कारण बन सकता है यदि कुंजी की स्थिति दर्जनाओं के बाद बदलती है, जिससे TreeMap के क्रम प्रभावित होते हैं।
समाधान: कुंजी क्लासेज़ को अपरिवर्तनीय बनाएं, फ़ील्ड्स को final घोषित करके और सेटर्स प्रदान नहीं करके।




		
		
			
			
Java
			
			public class Code implements Comparable&lt;Code&gt; {
    private final int lectureNumber;
    private final int sectionNumber;

    // Constructor and getters only
}

			
				
					
				
					1
2
3
4
5
6
7
				
						public class Code implements Comparable&lt;Code&gt; {
    private final int lectureNumber;
    private final int sectionNumber;
 
    // Constructor and getters only
}
 
					
				
			
		



निष्कर्ष
इस व्यापक मार्गदर्शिका में, हमने Java के Collections Framework के भीतर TreeMap की जटिलताओं का अन्वेषण किया है। TreeMap और HashMap के बीच मौलिक अंतर को समझने से लेकर कस्टम ऑब्जेक्ट्स के साथ TreeMap को लागू करने और उपयोग करने तक, इस eBook ने आपको अपने Java अनुप्रयोगों में TreeMap को प्रभावी ढंग से उपयोग करने के लिए आवश्यक ज्ञान से लैस किया है।
मुख्य सीख

TreeMap कुंजी के आधार पर क्रमबद्ध क्रम बनाए रखता है, जिससे यह क्रमबद्ध डेटा या सीमा क्वेरियों की आवश्यकता वाले परिदृश्यों के लिए आदर्श बनता है।
जब TreeMap में कस्टम ऑब्जेक्ट्स को कुंजियाँ के रूप में उपयोग किया जाता है, तो Comparable इंटरफ़ेस को लागू करना या एक Comparator प्रदान करना आवश्यक है।
संभावित ClassCastException से बचने के लिए compareTo, equals, और hashCode विधियों के बीच एकरूपता सुनिश्चित करें।
सर्वोत्तम अभ्यासों का पालन करना, जैसे अपरिवर्तनीयता का उपयोग करना और आवश्यक विधियों को ओवरराइड करना, आपके कोड की मजबूती और पठनीयता को बढ़ाता है।

अपने डेटा को कुशलतापूर्वक प्रबंधित करने के लिए TreeMap की शक्ति को अपनाएं, जिससे आपके Java अनुप्रयोगों में प्रदर्शन और क्रम दोनों सुनिश्चित हो सकें।
ध्यान दें: यह लेख AI द्वारा उत्पन्न किया गया है।

अतिरिक्त संसाधन

TreeMap के लिए आधिकारिक Java दस्तावेज़ीकरण
Java Collections Framework का अवलोकन
Effective Java लेखक Joshua Bloch


धन्यवाद Java Collections में TreeMap में महारत हासिल करना: एक व्यापक मार्गदर्शिका पढ़ने के लिए। कोडिंग खुश रखें!
विशेषता	TreeMap	HashMap
क्रमबद्धता	कुंजी के प्राकृतिक क्रम या एक कस्टम Comparator के आधार पर सॉर्टेड	कोई गारंटीकृत क्रम नहीं
प्रदर्शन	put, get, remove संचालन के लिए O(log n) समय	put, get, remove संचालन के लिए O(1) समय (औसत मामला)
Null Keys	शून्य कुंजी की अनुमति नहीं देता	एक शून्य कुंजी की अनुमति देता है
उपयोग परिदृश्य	जब क्रमबद्ध क्रम आवश्यक हो या सीमा-आधारित संचालन की आवश्यकता हो	जब बिना क्रम बाधाओं के तेज पहुँच आवश्यक हो
पहलू	TreeMap	HashMap
कार्यान्वयन	रेड-ब्लैक ट्री	हैश टेबल
समय जटिलता	put, get, remove के लिए O(log n)	put, get, remove के लिए O(1) (औसत मामला)
क्रमबद्धता	कुंजी द्वारा सॉर्टेड	कोई क्रम नहीं
Null Keys	अनुमत नहीं	एक शून्य कुंजी अनुमति है
मेमोरी ओवरहेड	ट्री संरचना के कारण अधिक	कम