S11L04 - Comparator इंटरफेस के साथ कस्टम सॉर्टिंग जारी

html

जावा में कस्टम सॉर्टिंग: Comparator इंटरफेस में प्रवीणता
सामग्री सूची

परिचय .................................................................1
TreeSet को समझना और इसकी सीमाएँ ...3
Comparator इंटरफेस का परिचय ............5
Comparator के साथ कस्टम सॉर्टिंग लागू करना ..7
व्यावहारिक उदाहरण: कस्टम ऑब्जेक्ट्स को सॉर्ट करना ....10
उन्नत Comparator परिदृश्य .........................14
निष्कर्ष .................................................................18


परिचय
जावा प्रोग्रामिंग के क्षेत्र में, object संग्रह को सॉर्ट करना एक मौलिक कार्य है। जबकि Java अंतर्निर्मित सॉर्टिंग मेकेनिज्म प्रदान करता है, विशिष्ट मानदंडों के आधार पर क्रम को अनुकूलित करना अक्सर Comparator जैसे इंटरफेस की गहरी समझ की मांग करता है। यह eBook Comparator इंटरफेस का उपयोग करके कस्टम सॉर्टिंग की जटिलताओं में गहराई से उतरता है, जो आपके डेटा को प्रभावी ढंग से प्रबंधित और मैनिपुलेट करने की क्षमता को बढ़ाता है।
मुख्य बिंदु:

TreeSet का अवलोकन और इसकी डिफ़ॉल्ट सॉर्टिंग व्यवहार।
अंतर्निर्मित सॉर्टिंग मेकेनिज्म की सीमाएँ।
Comparator इंटरफेस का परिचय कस्टम सॉर्टिंग के लिए।
कस्टम सॉर्टिंग लॉजिक का चरण-दर-चरण कार्यान्वयन।
व्यावहारिक उदाहरण और उन्नत परिदृश्य।

इस गाइड के अंत तक, आप अपने एप्लिकेशन की आवश्यकताओं के अनुरूप कस्टम सॉर्टिंग मेकेनिज्म को लागू करने के ज्ञान से सुसज्जित हो जाएंगे।

TreeSet को समझना और इसकी सीमाएँ
TreeSet का अवलोकन
TreeSet जावा के Collection Framework का हिस्सा है जो Set इंटरफेस को लागू करता है। यह तत्वों को सॉर्टेड और आरोही क्रम में संग्रहीत करता है, यह सुनिश्चित करता है कि कोई डुप्लिकेट तत्व मौजूद नहीं हैं। सॉर्टिंग तत्वों के प्राकृतिक क्रम या TreeSet निर्माण के समय प्रदान किए गए कस्टम Comparator पर आधारित होती है।
डिफ़ॉल्ट सॉर्टिंग व्यवहार
डिफ़ॉल्ट रूप से, TreeSet अपने तत्वों के प्राकृतिक क्रम का उपयोग करता है। उदाहरण के लिए, संख्याएँ आरोही संख्यात्मक क्रम में सॉर्ट की जाती हैं, और स्ट्रिंग्स लेक्सिकोग्राफिकली सॉर्ट की जाती हैं।




		
		
			
			
Java
			
			&lt;pre&gt;
&lt;code&gt;
TreeSet&lt;Integer&gt; numbers = new TreeSet&lt;&gt;();
numbers.add(3);
numbers.add(1);
numbers.add(2);
// The TreeSet will be [1, 2, 3]
&lt;/code&gt;
&lt;/pre&gt;
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						&lt;pre&gt;
&lt;code&gt;
TreeSet&lt;Integer&gt; numbers = new TreeSet&lt;&gt;();
numbers.add(3);
numbers.add(1);
numbers.add(2);
// The TreeSet will be [1, 2, 3]
&lt;/code&gt;
&lt;/pre&gt;
					
				
			
		


डिफ़ॉल्ट सॉर्टिंग की सीमाएँ
जबकि डिफ़ॉल्ट सॉर्टिंग व्यवहार सरल डेटा प्रकारों के लिए पर्याप्त है, यह कस्टम ऑब्जेक्ट्स के साथ काम करते समय कम पड़ जाता है। उदाहरण के लिए, अगर आपके पास एक User क्लास है जिसमें id और name जैसे गुण हैं, तो TreeSet स्वाभाविक रूप से इन गुणों के आधार पर User ऑब्जेक्ट्स को सॉर्ट नहीं कर सकता बिना अतिरिक्त निर्देशों के।
समस्या परिदृश्य:
मान लीजिए कि आपके पास TreeSet ऑफ User ऑब्जेक्ट्स है जहां आप उपयोगकर्ताओं को उनके id के आधार पर सॉर्ट करना चाहते हैं। डिफ़ॉल्ट Comparator यह नहीं जानता कि इस कस्टम सॉर्टिंग को कैसे संभालना है, जिससे अप्रत्याशित व्यवहार या runtime त्रुटियाँ हो सकती हैं।

Comparator इंटरफेस का परिचय
Comparator क्या है?
जावा में Comparator इंटरफेस कस्टम सॉर्टिंग लॉजिक को परिभाषित करने का एक तरीका प्रदान करता है। Comparable इंटरफेस के विपरीत, जो उस क्लास को संशोधित करने की आवश्यकता होती है जिसके ऑब्जेक्ट्स को सॉर्ट किया जा रहा है, Comparator आपको अलग-अलग सॉर्टिंग रणनीतियाँ परिभाषित करने की अनुमति देता है।
Comparator का उपयोग करने के लाभ

लचीलापन: विभिन्न सॉर्टिंग मानदंडों के लिए कई comparators परिभाषित किए जा सकते हैं।
Separation of Concerns: सॉर्टिंग लॉजिक ऑब्जेक्ट की परिभाषा से अलग होता है।
पुन: प्रयोज्यता: वही comparator विभिन्न संग्रहों में पुन: उपयोग किया जा सकता है।

Comparator बनाम Comparable


विशेषता
Comparable
Comparator


इंटरफेस प्रकार
Comparable एक सिंगल इंटरफेस है।
Comparator एक अलग इंटरफेस है।


मेमथड
compareTo() मेथड को लागू करता है।
compare() मेथड को लागू करता है।


उपयोग
क्लास के भीतर प्राकृतिक क्रम को परिभाषित करता है।
बाहरी रूप से कस्टम क्रम को परिभाषित करता है।


लचीलापन
कम लचीला; केवल एक तुलना रणनीति।
ज्यादा लचीला; कई तुलना रणनीतियाँ।



Comparator के साथ कस्टम सॉर्टिंग लागू करना
चरण-दर-चरण कार्यान्वयन
TreeSet की सीमाओं को पार करने के लिए कस्टम ऑब्जेक्ट्स के साथ, एक कस्टम Comparator लागू करने के लिए निम्न चरणों का पालन करें:

Comparator क्लास बनाएं: अपनी कस्टम क्लास के लिए Comparator इंटरफेस को लागू करें।
compare मेथड को ओवरराईड करें: compare मेथड के भीतर सॉर्टिंग लॉजिक को परिभाषित करें।
Comparator को TreeSet में पास करें: TreeSet को प्रारंभ करते समय कस्टम Comparator का उपयोग करें।

उदाहरण: ID के अनुसार Users को सॉर्ट करना




		
		
			
			
Java
			
			&lt;pre&gt;
&lt;code&gt;
import java.util.Comparator;

public class UserIdComparator implements Comparator&lt;User&gt; {
    @Override
    public int compare(User u1, User u2) {
        return Integer.compare(u1.getId(), u2.getId());
    }
}
&lt;/code&gt;
&lt;/pre&gt;
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
				
						&lt;pre&gt;
&lt;code&gt;
import java.util.Comparator;
 
public class UserIdComparator implements Comparator&lt;User&gt; {
    @Override
    public int compare(User u1, User u2) {
        return Integer.compare(u1.getId(), u2.getId());
    }
}
&lt;/code&gt;
&lt;/pre&gt;
					
				
			
		


Comparator को TreeSet के साथ एकीकृत करना




		
		
			
			
Java
			
			&lt;pre&gt;
&lt;code&gt;
import java.util.TreeSet;

public class Main {
    public static void main(String[] args) {
        TreeSet&lt;User&gt; users = new TreeSet&lt;&gt;(new UserIdComparator());

        users.add(new User(3, "Alice"));
        users.add(new User(1, "Bob"));
        users.add(new User(2, "Charlie"));

        for (User user : users) {
            System.out.println(user.getId() + ": " + user.getName());
        }
    }
}
&lt;/code&gt;
&lt;/pre&gt;
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
				
						&lt;pre&gt;
&lt;code&gt;
import java.util.TreeSet;
 
public class Main {
    public static void main(String[] args) {
        TreeSet&lt;User&gt; users = new TreeSet&lt;&gt;(new UserIdComparator());
 
        users.add(new User(3, "Alice"));
        users.add(new User(1, "Bob"));
        users.add(new User(2, "Charlie"));
 
        for (User user : users) {
            System.out.println(user.getId() + ": " + user.getName());
        }
    }
}
&lt;/code&gt;
&lt;/pre&gt;
					
				
			
		


आउटपुट:




		
		
			
			
Java
			
			1: Bob
2: Charlie
3: Alice
			
				
					
				
					1
2
3
				
						1: Bob
2: Charlie
3: Alice
					
				
			
		



व्यावहारिक उदाहरण: कस्टम ऑब्जेक्ट्स को सॉर्ट करना
User क्लास को परिभाषित करना




		
		
			
			
Java
			
			&lt;pre&gt;
&lt;code&gt;
public class User {
    private int id;
    private String name;

    // Constructor
    public User(int id, String name) {
        this.id = id;
        this.name = name;
    }

    // Getters
    public int getId() { return id; }
    public String getName() { return name; }
}
&lt;/code&gt;
&lt;/pre&gt;
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
				
						&lt;pre&gt;
&lt;code&gt;
public class User {
    private int id;
    private String name;
 
    // Constructor
    public User(int id, String name) {
        this.id = id;
        this.name = name;
    }
 
    // Getters
    public int getId() { return id; }
    public String getName() { return name; }
}
&lt;/code&gt;
&lt;/pre&gt;
					
				
			
		


Comparator को लागू करना




		
		
			
			
Java
			
			&lt;pre&gt;
&lt;code&gt;
import java.util.Comparator;

public class UserIdComparator implements Comparator&lt;User&gt; {
    @Override
    public int compare(User u1, User u2) {
        if (u1.getId() &lt; u2.getId()) {
            return -1;
        } else if (u1.getId() &gt; u2.getId()) {
            return 1;
        } else {
            return 0;
        }
    }
}
&lt;/code&gt;
&lt;/pre&gt;
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
				
						&lt;pre&gt;
&lt;code&gt;
import java.util.Comparator;
 
public class UserIdComparator implements Comparator&lt;User&gt; {
    @Override
    public int compare(User u1, User u2) {
        if (u1.getId() &lt; u2.getId()) {
            return -1;
        } else if (u1.getId() &gt; u2.getId()) {
            return 1;
        } else {
            return 0;
        }
    }
}
&lt;/code&gt;
&lt;/pre&gt;
					
				
			
		


Comparator का उपयोग TreeSet में करना




		
		
			
			
Java
			
			&lt;pre&gt;
&lt;code&gt;
import java.util.TreeSet;

public class Main {
    public static void main(String[] args) {
        TreeSet&lt;User&gt; users = new TreeSet&lt;&gt;(new UserIdComparator());

        users.add(new User(3, "Alice"));
        users.add(new User(1, "Bob"));
        users.add(new User(2, "Charlie"));
        users.add(new User(1, "David")); // Duplicate ID

        for (User user : users) {
            System.out.println(user.getId() + ": " + user.getName());
        }
    }
}
&lt;/code&gt;
&lt;/pre&gt;
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
				
						&lt;pre&gt;
&lt;code&gt;
import java.util.TreeSet;
 
public class Main {
    public static void main(String[] args) {
        TreeSet&lt;User&gt; users = new TreeSet&lt;&gt;(new UserIdComparator());
 
        users.add(new User(3, "Alice"));
        users.add(new User(1, "Bob"));
        users.add(new User(2, "Charlie"));
        users.add(new User(1, "David")); // Duplicate ID
 
        for (User user : users) {
            System.out.println(user.getId() + ": " + user.getName());
        }
    }
}
&lt;/code&gt;
&lt;/pre&gt;
					
				
			
		


आउटपुट:




		
		
			
			
Java
			
			1: Bob
2: Charlie
3: Alice
			
				
					
				
					1
2
3
				
						1: Bob
2: Charlie
3: Alice
					
				
			
		


व्याख्या:

TreeSet UserIdComparator का उपयोग करके User ऑब्जेक्ट्स को उनके id के आधार पर सॉर्ट करता है।
डुप्लिकेट IDs (जैसे, id = 1 के लिए Bob और David) Comparator द्वारा संभाले जाते हैं, जिससे दोनों को सेट में जोड़ा नहीं जा सकता।

कोड विभाजन




		
		
			
			
Java
			
			&lt;pre&gt;
&lt;code&gt;
// Comparator Implementation
public class UserIdComparator implements Comparator&lt;User&gt; {
    @Override
    public int compare(User u1, User u2) {
        // Compare based on user ID
        if (u1.getId() &lt; u2.getId()) {
            return -1; // u1 comes before u2
        } else if (u1.getId() &gt; u2.getId()) {
            return 1; // u1 comes after u2
        } else {
            return 0; // u1 and u2 are equal
        }
    }
}
&lt;/code&gt;
&lt;/pre&gt;
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
				
						&lt;pre&gt;
&lt;code&gt;
// Comparator Implementation
public class UserIdComparator implements Comparator&lt;User&gt; {
    @Override
    public int compare(User u1, User u2) {
        // Compare based on user ID
        if (u1.getId() &lt; u2.getId()) {
            return -1; // u1 comes before u2
        } else if (u1.getId() &gt; u2.getId()) {
            return 1; // u1 comes after u2
        } else {
            return 0; // u1 and u2 are equal
        }
    }
}
&lt;/code&gt;
&lt;/pre&gt;
					
				
			
		






		
		
			
			
Java
			
			&lt;pre&gt;
&lt;code&gt;
// Main Class with TreeSet
public class Main {
    public static void main(String[] args) {
        // Initialize TreeSet with custom comparator
        TreeSet&lt;User&gt; users = new TreeSet&lt;&gt;(new UserIdComparator());

        // Adding users
        users.add(new User(3, "Alice"));
        users.add(new User(1, "Bob"));
        users.add(new User(2, "Charlie"));
        users.add(new User(1, "David")); // Will not be added due to duplicate ID

        // Iterating over TreeSet
        for (User user : users) {
            System.out.println(user.getId() + ": " + user.getName());
        }
    }
}
&lt;/code&gt;
&lt;/pre&gt;
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
				
						&lt;pre&gt;
&lt;code&gt;
// Main Class with TreeSet
public class Main {
    public static void main(String[] args) {
        // Initialize TreeSet with custom comparator
        TreeSet&lt;User&gt; users = new TreeSet&lt;&gt;(new UserIdComparator());
 
        // Adding users
        users.add(new User(3, "Alice"));
        users.add(new User(1, "Bob"));
        users.add(new User(2, "Charlie"));
        users.add(new User(1, "David")); // Will not be added due to duplicate ID
 
        // Iterating over TreeSet
        for (User user : users) {
            System.out.println(user.getId() + ": " + user.getName());
        }
    }
}
&lt;/code&gt;
&lt;/pre&gt;
					
				
			
		


मुख्य अवधारणाएँ:

Comparator इंटरफेस: कस्टम सॉर्टिंग लॉजिक को सक्षम बनाता है।
compare मेथड: ऑब्जेक्ट्स के क्रम को निर्धारित करता है।
TreeSet एकीकरण: सॉर्टिंग के लिए TreeSet में Comparator पास करता है।


उन्नत Comparator परिदृश्य
कई मानदंडों के आधार पर सॉर्ट करना
कभी-कभी, एकल गुण के आधार पर सॉर्ट करना पर्याप्त नहीं होता है। आपको वस्तुओं को कई गुणों के आधार पर सॉर्ट करने की आवश्यकता हो सकती है। उदाहरण के लिए, User ऑब्जेक्ट्स को पहले id के आधार पर और फिर name के आधार पर सॉर्ट करना।




		
		
			
			
Java
			
			&lt;pre&gt;
&lt;code&gt;
import java.util.Comparator;

public class UserMultiComparator implements Comparator&lt;User&gt; {
    @Override
    public int compare(User u1, User u2) {
        if (u1.getId() != u2.getId()) {
            return Integer.compare(u1.getId(), u2.getId());
        } else {
            return u1.getName().compareTo(u2.getName());
        }
    }
}
&lt;/code&gt;
&lt;/pre&gt;
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
				
						&lt;pre&gt;
&lt;code&gt;
import java.util.Comparator;
 
public class UserMultiComparator implements Comparator&lt;User&gt; {
    @Override
    public int compare(User u1, User u2) {
        if (u1.getId() != u2.getId()) {
            return Integer.compare(u1.getId(), u2.getId());
        } else {
            return u1.getName().compareTo(u2.getName());
        }
    }
}
&lt;/code&gt;
&lt;/pre&gt;
					
				
			
		


उपयोग:




		
		
			
			
Java
			
			&lt;pre&gt;
TreeSet&lt;User&gt; users = new TreeSet&lt;&gt;(new UserMultiComparator());
&lt;/pre&gt;
			
				
					
				
					1
2
3
				
						&lt;pre&gt;
TreeSet&lt;User&gt; users = new TreeSet&lt;&gt;(new UserMultiComparator());
&lt;/pre&gt;
					
				
			
		


ऑब्जेक्ट गुणों के आधार पर गतिशील रूप से सॉर्ट करना
आप Comparator बना सकते हैं जो कुछ शर्तों या इनपुट पैरामीटर के आधार पर रनटाइम में सॉर्टिंग मानदंड निर्धारित करता है।




		
		
			
			
Java
			
			&lt;pre&gt;
&lt;code&gt;
import java.util.Comparator;

public class DynamicUserComparator implements Comparator&lt;User&gt; {
    private String attribute;

    public DynamicUserComparator(String attribute) {
        this.attribute = attribute;
    }

    @Override
    public int compare(User u1, User u2) {
        switch (attribute) {
            case "name":
                return u1.getName().compareTo(u2.getName());
            case "id":
            default:
                return Integer.compare(u1.getId(), u2.getId());
        }
    }
}
&lt;/code&gt;
&lt;/pre&gt;
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
				
						&lt;pre&gt;
&lt;code&gt;
import java.util.Comparator;
 
public class DynamicUserComparator implements Comparator&lt;User&gt; {
    private String attribute;
 
    public DynamicUserComparator(String attribute) {
        this.attribute = attribute;
    }
 
    @Override
    public int compare(User u1, User u2) {
        switch (attribute) {
            case "name":
                return u1.getName().compareTo(u2.getName());
            case "id":
            default:
                return Integer.compare(u1.getId(), u2.getId());
        }
    }
}
&lt;/code&gt;
&lt;/pre&gt;
					
				
			
		


उपयोग:




		
		
			
			
Java
			
			&lt;pre&gt;
TreeSet&lt;User&gt; usersByName = new TreeSet&lt;&gt;(new DynamicUserComparator("name"));
TreeSet&lt;User&gt; usersById = new TreeSet&lt;&gt;(new DynamicUserComparator("id"));
&lt;/pre&gt;
			
				
					
				
					1
2
3
4
				
						&lt;pre&gt;
TreeSet&lt;User&gt; usersByName = new TreeSet&lt;&gt;(new DynamicUserComparator("name"));
TreeSet&lt;User&gt; usersById = new TreeSet&lt;&gt;(new DynamicUserComparator("id"));
&lt;/pre&gt;
					
				
			
		


Comparator के लिए Lambda Expressions
जावा 8 ने lambda expressions पेश किए, जिससे अलग-अलग क्लासेज़ की आवश्यकता के बिना comparators बनाना सरल हो गया है।




		
		
			
			
Java
			
			&lt;pre&gt;
&lt;code&gt;
TreeSet&lt;User&gt; users = new TreeSet&lt;&gt;((u1, u2) -&gt; {
    if (u1.getId() &lt; u2.getId()) {
        return -1;
    } else if (u1.getId() &gt; u2.getId()) {
        return 1;
    } else {
        return u1.getName().compareTo(u2.getName());
    }
});
&lt;/code&gt;
&lt;/pre&gt;
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
				
						&lt;pre&gt;
&lt;code&gt;
TreeSet&lt;User&gt; users = new TreeSet&lt;&gt;((u1, u2) -&gt; {
    if (u1.getId() &lt; u2.getId()) {
        return -1;
    } else if (u1.getId() &gt; u2.getId()) {
        return 1;
    } else {
        return u1.getName().compareTo(u2.getName());
    }
});
&lt;/code&gt;
&lt;/pre&gt;
					
				
			
		


लाभ:

संक्षिप्त और पठनीय।
कई comparator क्लासेज़ की आवश्यकता को समाप्त करता है।

null मानों को संभालना
जब आप ऐसे ऑब्जेक्ट्स को सॉर्ट कर रहे होते हैं जिनमें null मान हो सकते हैं, तो इन्हें संभालना आवश्यक होता है ताकि NullPointerException से बचा जा सके।




		
		
			
			
Java
			
			&lt;pre&gt;
&lt;code&gt;
import java.util.Comparator;

public class SafeUserComparator implements Comparator&lt;User&gt; {
    @Override
    public int compare(User u1, User u2) {
        if (u1 == null && u2 == null) return 0;
        if (u1 == null) return -1;
        if (u2 == null) return 1;

        return Integer.compare(u1.getId(), u2.getId());
    }
}
&lt;/code&gt;
&lt;/pre&gt;
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
				
						&lt;pre&gt;
&lt;code&gt;
import java.util.Comparator;
 
public class SafeUserComparator implements Comparator&lt;User&gt; {
    @Override
    public int compare(User u1, User u2) {
        if (u1 == null && u2 == null) return 0;
        if (u1 == null) return -1;
        if (u2 == null) return 1;
 
        return Integer.compare(u1.getId(), u2.getId());
    }
}
&lt;/code&gt;
&lt;/pre&gt;
					
				
			
		



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

TreeSet को समझना: इसके डिफ़ॉल्ट सॉर्टिंग व्यवहार और कस्टम ऑब्जेक्ट्स के साथ इसकी सीमाओं को पहचानना।
Comparator इंटरफेस: कस्टम comparators को परिभाषित और लागू करने में दक्षता प्राप्त करना।
व्यावहारिक कार्यान्वयन: संग्रहों के साथ comparators को प्रभावी ढंग से एकीकृत करना सीखना।
उन्नत तकनीक: मल्टी-क्राइटेरिया सॉर्टिंग, डायनामिक comparators, और कोड को साफ़ बनाने के लिए lambda expressions का अन्वेषण करना।

कार्रवाई के लिए कॉल: अपने जावा प्रोजेक्ट्स में कस्टम सॉर्टिंग के साथ प्रयोग करें। अलग-अलग comparator रणनीतियों को लागू करें और देखें कि वे आपके संग्रहों के क्रम को कैसे प्रभावित करते हैं। Comparator इंटरफेस द्वारा प्रदान की गई लचीलापन को अपनाएँ ताकि आप मजबूत और कुशल एप्लिकेशन बना सकें।
SEO Keywords: Java Comparator, Custom Sorting Java, TreeSet Comparator, Java Collections, Implement Comparator, Java Sorting Techniques, Comparator Interface, Java Developer Guide, Custom Object Sorting, Advanced Java Sorting
Note: This article is AI generated.
विशेषता	Comparable	Comparator
इंटरफेस प्रकार	Comparable एक सिंगल इंटरफेस है।	Comparator एक अलग इंटरफेस है।
मेमथड	compareTo() मेथड को लागू करता है।	compare() मेथड को लागू करता है।
उपयोग	क्लास के भीतर प्राकृतिक क्रम को परिभाषित करता है।	बाहरी रूप से कस्टम क्रम को परिभाषित करता है।
लचीलापन	कम लचीला; केवल एक तुलना रणनीति।	ज्यादा लचीला; कई तुलना रणनीतियाँ।