S11L14 - कुछ और चीजें - खंड समापन

html

Java Collections में महारत: Sets, Lists, और कुशल खोज
विषय सूची

परिचय ............................................................... 1
Java Sets को समझना .................................... 3
Set को List में बदलना ................................... 6
Java में Lists को सॉर्ट करना ........................................ 9
Binary Search को लागू करना .......................... 12
Collections में Custom Objects के साथ काम करना .................................................... 16
निष्कर्ष ................................................................. 21


परिचय
Java Collections Framework प्रभावी Java प्रोग्रामिंग का एक आधारस्तंभ है, जो डेटा समूहों को संग्रहित और प्रबंधित करने के लिए कक्षाओं और इंटरफेसेस का सेट प्रदान करता है। सबसे अधिक उपयोग किए जाने वाले collections में Sets और Lists शामिल हैं, जो प्रत्येक अलग उद्देश्यों की सेवा करते हैं और अद्वितीय कार्यक्षमताएँ प्रदान करते हैं। इन collections का प्रभावी ढंग से उपयोग करना, उनके बीच रूपांतरण करना, और सॉर्टिंग तथा सर्चिंग जैसी ऑपरेशंस करना शुरुआती और अनुभवी डेवलपर्स दोनों के लिए आवश्यक है।
इस eBook में, हम Java Sets और Lists की गहराई में जाते हैं, यह बताते हुए कि कैसे Sets का उपयोग करके डुप्लिकेट मानों को समाप्त करें, आदेशबद्ध ऑपरेशंस के लिए Sets को Lists में बदलें, डेटा को कुशलता से सॉर्ट करें, और तेजी से डेटा पुनर्प्राप्ति के लिए binary search को लागू करें। इसके अतिरिक्त, हम इन collections में custom objects के साथ काम करने का तरीका भी देखेंगे, जिससे डेटा की अखंडता और अनुकूल प्रदर्शन सुनिश्चित किया जा सके।


अध्याय
पृष्ठ संख्या


परिचय
1


Java Sets को समझना
3


Set को List में बदलना
6


Java में Lists को सॉर्ट करना
9


Binary Search को लागू करना
12


Collections में Custom Objects के साथ काम करना
16


निष्कर्ष
21



Java Sets को समझना
Set क्या है?
Java में एक Set ऐसी collection है जो डुप्लिकेट तत्वों की अनुमति नहीं देती। यह गणितीय सेट अमूर्तता को मॉडल करता है और Java Collections Framework का हिस्सा है। Sets विशेष रूप से तब उपयोगी होते हैं जब तत्वों की विशिष्टता प्राथमिकता हो।
Sets की प्रमुख विशेषताएँ

डुप्लिकेट नहीं: सुनिश्चित करता है कि प्रत्येक तत्व अद्वितीय है।
अनऑर्डरड: तत्वों के क्रम की गारंटी नहीं देता (विशिष्ट implementations जैसे LinkedHashSet को छोड़कर)।
कुशल ऑपरेशंस: बुनियादी ऑपरेशंस जैसे add, remove, और contains के लिए constant-time प्रदर्शन प्रदान करता है, बशर्ते hash function तत्वों को ठीक से वितरित करे।

आम Set implementations

HashSet: सबसे अधिक उपयोग किया जाने वाला Set implementation। यह एक hash table द्वारा समर्थित है और बुनियादी ऑपरेशंस के लिए constant-time प्रदर्शन प्रदान करता है।
LinkedHashSet: सेट में एंट्रीज की एक linked list बनाए रखता है, जिससे इन्सर्शन ऑर्डर संरक्षित रहता है।
TreeSet: SortedSet इंटरफेस को लागू करता है और तत्वों को एक sorted tree संरचना में संग्रहीत करता है।

Set का उपयोग कब करें?

डुप्लिकेट को समाप्त करना: जब आपको अद्वितीय तत्वों को संग्रहित करने की आवश्यकता हो।
मेम्बरशिप टेस्टिंग: कुशलता से जांचना कि क्या कोई तत्व collection में मौजूद है।
गणितीय सेट ऑपरेशंस: यूनियन्स, इंटरसेक्शन्स, और डिफरेंसेस करना।

Sets के उपयोग के फायदे और नुकसान


फायदे
नुकसान


तत्वों की अनूठीता सुनिश्चित करता है
तत्वों के क्रम पर नियंत्रण नहीं


आमतौर पर तेज प्रदर्शन प्रदान करता है
Lists की तुलना में उच्च मेमोरी खपत


गणितीय सेट ऑपरेशंस के लिए उपयुक्त
Lists की तुलना में सीमित इंटरफेस



Set को List में बदलना
Set को List में क्यों बदलें?
जबकि Sets अनूठीता सुनिश्चित करने में उत्कृष्ट हैं, Lists ordered collections प्रदान करते हैं और डुप्लिकेट तत्वों की अनुमति देते हैं। Set को List में बदलना उपयोगी हो सकता है जब आपको ऐसे ऑपरेशंस करने की आवश्यकता हो जो ऑर्डरिंग या इंडेक्स्ड एक्सेस की मांग करें, जैसे कि सॉर्टिंग या binary searching।
Step-बाय-Step Conversion

Set को initialize करें:

    



		
		
			
			
Java
			
			Set<String> namesSet = new HashSet<>();
namesSet.add("John");
namesSet.add("Afia");
namesSet.add("Chand");
namesSet.add("John"); // Duplicate, will be ignored
			
				
					
				
					1
2
3
4
5
				
						Set<String> namesSet = new HashSet<>();
namesSet.add("John");
namesSet.add("Afia");
namesSet.add("Chand");
namesSet.add("John"); // Duplicate, will be ignored
					
				
			
		


  
Set को List में बदलें:

    



		
		
			
			
Java
			
			List<String> namesList = new ArrayList<>();
namesList.addAll(namesSet);
			
				
					
				
					1
2
				
						List<String> namesList = new ArrayList<>();
namesList.addAll(namesSet);
					
				
			
		



    वैकल्पिक रूप से, constructor का उपयोग करके:

    



		
		
			
			
Java
			
			List<String> namesList = new ArrayList<>(namesSet);
			
				
					
				
					1
				
						List<String> namesList = new ArrayList<>(namesSet);
					
				
			
		


  
Conversion की पुष्टि करें:

    



		
		
			
			
Java
			
			System.out.println(namesList);
// Output: [John, Afia, Chand]
			
				
					
				
					1
2
				
						System.out.println(namesList);
// Output: [John, Afia, Chand]
					
				
			
		


  

Code Example




		
		
			
			
Java
			
			import java.util.*;

public class SetToListExample {
    public static void main(String[] args) {
        // Duplicate मानों के साथ Set initialize करें
        Set<String> namesSet = new HashSet<>();
        namesSet.add("John");
        namesSet.add("Afia");
        namesSet.add("Chand");
        namesSet.add("John"); // Duplicate entry

        // Set को List में बदलें
        List<String> namesList = new ArrayList<>();
        namesList.addAll(namesSet);

        // List को प्रदर्शित करें
        System.out.println("Set से List में बदलने के बाद की List: " + namesList);
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
				
						import java.util.*;
 
public class SetToListExample {
    public static void main(String[] args) {
        // Duplicate मानों के साथ Set initialize करें
        Set<String> namesSet = new HashSet<>();
        namesSet.add("John");
        namesSet.add("Afia");
        namesSet.add("Chand");
        namesSet.add("John"); // Duplicate entry
 
        // Set को List में बदलें
        List<String> namesList = new ArrayList<>();
        namesList.addAll(namesSet);
 
        // List को प्रदर्शित करें
        System.out.println("Set से List में बदलने के बाद की List: " + namesList);
    }
}
					
				
			
		


Output:




		
		
			
			
Java
			
			Set से List में बदलने के बाद की List: [John, Afia, Chand]
			
				
					
				
					1
				
						Set से List में बदलने के बाद की List: [John, Afia, Chand]
					
				
			
		


मुख्य बिंदु

Duplicate निकालना: Conversion के दौरान, अगर Set में डुप्लिकेट होते हैं तो वे स्वाभाविक रूप से हटा दिए जाते हैं।
लचीलापन: Conversion के बाद Lists अधिक लचीलापन प्रदान करती हैं जैसे कि ordered ऑपरेशंस के लिए।
प्रदर्शन: Conversion आमतौर पर कुशल होता है, लेकिन उपयोग के मामले के आधार पर सही डेटा संरचनाओं का चयन करना आवश्यक है।


Java में Lists को सॉर्ट करना
Sorting का महत्व
Sorting एक मौलिक ऑपरेशन है जो डेटा को एक निर्दिष्ट क्रम में व्यवस्थित करता है, जिससे अन्य ऑपरेशंस जैसे सर्चिंग और इंडेक्सिंग की दक्षता बढ़ती है। Java Lists को आसानी से सॉर्ट करने के लिए मजबूत मेकेनिज़्म प्रदान करता है।
Strings की List को सॉर्ट करना
Collections.sort() मेथड का उपयोग करके, आप Strings की List को natural (alphabetical) order में सॉर्ट कर सकते हैं।




		
		
			
			
Java
			
			List<String> namesList = new ArrayList<>(Arrays.asList("John", "Afia", "Chand"));
Collections.sort(namesList);
System.out.println("Sorted List: " + namesList);
			
				
					
				
					1
2
3
				
						List<String> namesList = new ArrayList<>(Arrays.asList("John", "Afia", "Chand"));
Collections.sort(namesList);
System.out.println("Sorted List: " + namesList);
					
				
			
		


Output:




		
		
			
			
Java
			
			Sorted List: [Afia, Chand, John]
			
				
					
				
					1
				
						Sorted List: [Afia, Chand, John]
					
				
			
		


Custom Objects की List को सॉर्ट करना
Custom objects की List को सॉर्ट करने के लिए, objects को Comparable इंटरफेस को implement करना होगा या Comparator प्रदान करना होगा।
Comparable को लागू करना

Class बनाएं:

    



		
		
			
			
Java
			
			public class Name implements Comparable<Name> {
    private String name;

    public Name(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    @Override
    public int compareTo(Name o) {
        return this.name.compareTo(o.getName());
    }

    @Override
    public String toString() {
        return this.name;
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
				
						public class Name implements Comparable<Name> {
    private String name;
 
    public Name(String name) {
        this.name = name;
    }
 
    public String getName() {
        return name;
    }
 
    @Override
    public int compareTo(Name o) {
        return this.name.compareTo(o.getName());
    }
 
    @Override
    public String toString() {
        return this.name;
    }
}
					
				
			
		


  
List को सॉर्ट करें:

    



		
		
			
			
Java
			
			List<Name> nameList = new ArrayList<>();
nameList.add(new Name("John"));
nameList.add(new Name("Afia"));
nameList.add(new Name("Chand"));

Collections.sort(nameList);
System.out.println("Sorted Name List: " + nameList);
			
				
					
				
					1
2
3
4
5
6
7
				
						List<Name> nameList = new ArrayList<>();
nameList.add(new Name("John"));
nameList.add(new Name("Afia"));
nameList.add(new Name("Chand"));
 
Collections.sort(nameList);
System.out.println("Sorted Name List: " + nameList);
					
				
			
		


  

Output:




		
		
			
			
Java
			
			Sorted Name List: [Afia, Chand, John]
			
				
					
				
					1
				
						Sorted Name List: [Afia, Chand, John]
					
				
			
		


Code Example




		
		
			
			
Java
			
			import java.util.*;

class Name implements Comparable<Name> {
    private String name;

    public Name(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    // Natural ordering के लिए compareTo implement करें
    @Override
    public int compareTo(Name o) {
        return this.name.compareTo(o.getName());
    }

    @Override
    public String toString() {
        return this.name;
    }
}

public class SortingExample {
    public static void main(String[] args) {
        // Name objects की list बनाएं
        List<Name> nameList = new ArrayList<>();
        nameList.add(new Name("John"));
        nameList.add(new Name("Afia"));
        nameList.add(new Name("Chand"));

        // List को सॉर्ट करें
        Collections.sort(nameList);

        // सॉर्ट की हुई List को प्रदर्शित करें
        System.out.println("Sorted Name List: " + nameList);
    }
}
			
				
					
				
					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
				
						import java.util.*;
 
class Name implements Comparable<Name> {
    private String name;
 
    public Name(String name) {
        this.name = name;
    }
 
    public String getName() {
        return name;
    }
 
    // Natural ordering के लिए compareTo implement करें
    @Override
    public int compareTo(Name o) {
        return this.name.compareTo(o.getName());
    }
 
    @Override
    public String toString() {
        return this.name;
    }
}
 
public class SortingExample {
    public static void main(String[] args) {
        // Name objects की list बनाएं
        List<Name> nameList = new ArrayList<>();
        nameList.add(new Name("John"));
        nameList.add(new Name("Afia"));
        nameList.add(new Name("Chand"));
 
        // List को सॉर्ट करें
        Collections.sort(nameList);
 
        // सॉर्ट की हुई List को प्रदर्शित करें
        System.out.println("Sorted Name List: " + nameList);
    }
}
					
				
			
		


Output:




		
		
			
			
Java
			
			Sorted Name List: [Afia, Chand, John]
			
				
					
				
					1
				
						Sorted Name List: [Afia, Chand, John]
					
				
			
		


मुख्य बिंदु

Natural Ordering: Implementing Comparable allows objects to be sorted based on a natural attribute.
Custom Sorting: Use Comparator for flexible sorting criteria without modifying the object's class.
Efficiency: Collections.sort() is optimized for performance, making it suitable for large datasets.


Binary Search को लागू करना
Binary Search क्या है?
Binary search एक कुशल algorithm है जो sorted list में से किसी item को खोजने के लिए उपयोग किया जाता है। यह search interval को लगातार आधा करके काम करता है, जिससे time complexity O(log n) हो जाती है, जो बड़े datasets के लिए linear search की तुलना में काफी तेज है।
Binary Search के लिए आवश्यकताएँ

Sorted List: Binary search करने से पहले list को ascending या descending order में सॉर्ट करना आवश्यक है।
Random Access: Lists को elements तक तेज random access का समर्थन करना चाहिए (उदा. ArrayList)।

Java में Binary Search करना
Java Collections.binarySearch() मेथड प्रदान करता है जो List पर binary search करने के लिए उपयोग किया जा सकता है।




		
		
			
			
Java
			
			import java.util.*;

public class BinarySearchExample {
    public static void main(String[] args) {
        List<String> namesList = new ArrayList<>(Arrays.asList("Afia", "Chand", "John"));
        Collections.sort(namesList); // सुनिश्चित करें कि list सॉर्टेड है

        // मौजूदा तत्व के लिए खोजें
        int index = Collections.binarySearch(namesList, "John");
        System.out.println("John का Index: " + index); // Output: 2

        // गैर-मौजूदा तत्व के लिए खोजें
        int negativeIndex = Collections.binarySearch(namesList, "john"); // Case-sensitive
        System.out.println("john का Index: " + negativeIndex); // Output: -4
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
				
						import java.util.*;
 
public class BinarySearchExample {
    public static void main(String[] args) {
        List<String> namesList = new ArrayList<>(Arrays.asList("Afia", "Chand", "John"));
        Collections.sort(namesList); // सुनिश्चित करें कि list सॉर्टेड है
 
        // मौजूदा तत्व के लिए खोजें
        int index = Collections.binarySearch(namesList, "John");
        System.out.println("John का Index: " + index); // Output: 2
 
        // गैर-मौजूदा तत्व के लिए खोजें
        int negativeIndex = Collections.binarySearch(namesList, "john"); // Case-sensitive
        System.out.println("john का Index: " + negativeIndex); // Output: -4
    }
}
					
				
			
		


Output:




		
		
			
			
Java
			
			John का Index: 2
john का Index: -4
			
				
					
				
					1
2
				
						John का Index: 2
john का Index: -4
					
				
			
		


Output को समझना

Positive Index: सूची में तत्व के स्थान को संकेत करता है।
Negative Index: संकेत करता है कि तत्व मौजूद नहीं है। मान -4 सुझाव देता है कि यदि "john" को जोड़ा जाता, तो वह index 3 पर होता (-(-4) - 1 = 3)।

Custom Objects के साथ Code Example




		
		
			
			
Java
			
			import java.util.*;

class Name implements Comparable<Name> {
    private String name;

    public Name(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    @Override
    public int compareTo(Name o) {
        return this.name.compareTo(o.getName());
    }

    @Override
    public String toString() {
        return this.name;
    }
}

public class BinarySearchCustomObject {
    public static void main(String[] args) {
        List<Name> nameList = new ArrayList<>();
        nameList.add(new Name("Afia"));
        nameList.add(new Name("Chand"));
        nameList.add(new Name("John"));

        // सुनिश्चित करें कि list सॉर्टेड है
        Collections.sort(nameList);

        // मौजूदा object के लिए खोजें
        Name searchName = new Name("John");
        int index = Collections.binarySearch(nameList, searchName);
        System.out.println("John का Index: " + index); // Output: 2

        // गैर-मौजूदा object के लिए खोजें
        Name nonExistingName = new Name("john"); // Case-sensitive
        int negativeIndex = Collections.binarySearch(nameList, nonExistingName);
        System.out.println("john का Index: " + negativeIndex); // Output: -4
    }
}
			
				
					
				
					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
				
						import java.util.*;
 
class Name implements Comparable<Name> {
    private String name;
 
    public Name(String name) {
        this.name = name;
    }
 
    public String getName() {
        return name;
    }
 
    @Override
    public int compareTo(Name o) {
        return this.name.compareTo(o.getName());
    }
 
    @Override
    public String toString() {
        return this.name;
    }
}
 
public class BinarySearchCustomObject {
    public static void main(String[] args) {
        List<Name> nameList = new ArrayList<>();
        nameList.add(new Name("Afia"));
        nameList.add(new Name("Chand"));
        nameList.add(new Name("John"));
 
        // सुनिश्चित करें कि list सॉर्टेड है
        Collections.sort(nameList);
 
        // मौजूदा object के लिए खोजें
        Name searchName = new Name("John");
        int index = Collections.binarySearch(nameList, searchName);
        System.out.println("John का Index: " + index); // Output: 2
 
        // गैर-मौजूदा object के लिए खोजें
        Name nonExistingName = new Name("john"); // Case-sensitive
        int negativeIndex = Collections.binarySearch(nameList, nonExistingName);
        System.out.println("john का Index: " + negativeIndex); // Output: -4
    }
}
					
				
			
		


Output:




		
		
			
			
Java
			
			John का Index: 2
john का Index: -4
			
				
					
				
					1
2
				
						John का Index: 2
john का Index: -4
					
				
			
		


मुख्य बिंदु

Efficiency: Binary search search समय को बड़े, sorted lists के लिए कम करता है।
Case Sensitivity: खोज case-sensitive होती है। खोज के दौरान consistent casing सुनिश्चित करें।
Custom Objects: Lists of custom objects पर binary search करने के लिए Comparable implement करें।


Collections में Custom Objects के साथ काम करना
equals और hashCode को ओवरराइड करने का महत्व
जब आप Set या Map में custom objects के साथ काम करते हैं, तो यह महत्वपूर्ण है कि equals और hashCode मेथड्स को Override करें। ये मेथड्स सुनिश्चित करते हैं कि collection डुप्लिकेट तत्वों की सही पहचान कर सके और object की अनूठीता को प्रबंधित कर सके।
equals और hashCode को implement करना




		
		
			
			
Java
			
			public class Name implements Comparable<Name> {
    private String name;

    public Name(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    // Meaningful output के लिए toString को ओवरराइड करना
    @Override
    public String toString() {
        return this.name;
    }

    // 'name' field के आधार पर Name objects की तुलना के लिए equals को ओवरराइड करना
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Name name1 = (Name) o;

        return name != null ? name.equals(name1.name) : name1.name == null;
    }

    // equals के साथ मेल खाने के लिए hashCode को ओवरराइड करना
    @Override
    public int hashCode() {
        return name != null ? name.hashCode() : 0;
    }

    // Natural ordering के लिए Comparable को implement करना
    @Override
    public int compareTo(Name o) {
        return this.name.compareTo(o.getName());
    }
}
			
				
					
				
					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
				
						public class Name implements Comparable<Name> {
    private String name;
 
    public Name(String name) {
        this.name = name;
    }
 
    public String getName() {
        return name;
    }
 
    // Meaningful output के लिए toString को ओवरराइड करना
    @Override
    public String toString() {
        return this.name;
    }
 
    // 'name' field के आधार पर Name objects की तुलना के लिए equals को ओवरराइड करना
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
 
        Name name1 = (Name) o;
 
        return name != null ? name.equals(name1.name) : name1.name == null;
    }
 
    // equals के साथ मेल खाने के लिए hashCode को ओवरराइड करना
    @Override
    public int hashCode() {
        return name != null ? name.hashCode() : 0;
    }
 
    // Natural ordering के लिए Comparable को implement करना
    @Override
    public int compareTo(Name o) {
        return this.name.compareTo(o.getName());
    }
}
					
				
			
		


Set में Custom Objects का उपयोग करना




		
		
			
			
Java
			
			import java.util.*;

public class CustomObjectSet {
    public static void main(String[] args) {
        Set<Name> namesSet = new HashSet<>();
        namesSet.add(new Name("John"));
        namesSet.add(new Name("Afia"));
        namesSet.add(new Name("Chand"));
        namesSet.add(new Name("John")); // Duplicate, will be ignored

        System.out.println("Set Contents: " + namesSet);
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
				
						import java.util.*;
 
public class CustomObjectSet {
    public static void main(String[] args) {
        Set<Name> namesSet = new HashSet<>();
        namesSet.add(new Name("John"));
        namesSet.add(new Name("Afia"));
        namesSet.add(new Name("Chand"));
        namesSet.add(new Name("John")); // Duplicate, will be ignored
 
        System.out.println("Set Contents: " + namesSet);
    }
}
					
				
			
		


Output:




		
		
			
			
Java
			
			Set Contents: [Afia, Chand, John]
			
				
					
				
					1
				
						Set Contents: [Afia, Chand, John]
					
				
			
		


Comparable Interface को Implement करना
Comparable इंटरफेस को implement करने से custom objects को natural ordering मिलती है, जो सॉर्टिंग और binary searching जैसे ऑपरेशन्स के लिए आवश्यक है।




		
		
			
			
Java
			
			@Override
public int compareTo(Name o) {
    return this.name.compareTo(o.getName());
}
			
				
					
				
					1
2
3
4
				
						@Override
public int compareTo(Name o) {
    return this.name.compareTo(o.getName());
}
					
				
			
		


आम गलतियां और उन्हें कैसे बचें

hashCode को ओवरराइड करना भूलना:

Issue: hash-based collections में अप्रत्याशित व्यवहार उत्पन्न हो जाता है।
Solution: जब भी equals को ओवरराइड करें, हमेशा hashCode को भी ओवरराइड करें।


equals और hashCode में असंगति:

Issue: Collections अप्रत्याशित रूप से व्यवहार कर सकते हैं।
Solution: सुनिश्चित करें कि अगर दो objects equals() के अनुसार समान हैं, तो उन्हें समान hashCode होना चाहिए।


compareTo Implementation में त्रुटि:

Issue: गलत सॉर्टिंग या searching व्यवहार का परिणाम होता है।
Solution: सुनिश्चित करें कि compareTo objects की natural ordering को सही ढंग से प्रतिबिंबित करता है।



Comments के साथ Code Example




		
		
			
			
Java
			
			import java.util.*;

class Name implements Comparable<Name> {
    private String name;

    public Name(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    // Meaningful output के लिए toString को ओवरराइड करना
    @Override
    public String toString() {
        return this.name;
    }

    // 'name' field के आधार पर Name objects की तुलना के लिए equals को ओवरराइड करना
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Name name1 = (Name) o;

        return name != null ? name.equals(name1.name) : name1.name == null;
    }

    // equals के साथ मेल खाने के लिए hashCode को ओवरराइड करना
    @Override
    public int hashCode() {
        return name != null ? name.hashCode() : 0;
    }

    // 'name' के आधार पर natural ordering के लिए Comparable को implement करना
    @Override
    public int compareTo(Name o) {
        return this.name.compareTo(o.getName());
    }
}

public class CustomObjectCollection {
    public static void main(String[] args) {
        // Name objects का Set बनाना
        Set<Name> namesSet = new HashSet<>();
        namesSet.add(new Name("John"));
        namesSet.add(new Name("Afia"));
        namesSet.add(new Name("Chand"));
        namesSet.add(new Name("John")); // Duplicates, equals और hashCode के कारण ignore किया जाएगा

        System.out.println("Set Contents: " + namesSet);

        // Set को ordered operations के लिए List में बदलना
        List<Name> namesList = new ArrayList<>(namesSet);
        Collections.sort(namesList); // List को सॉर्ट करना

        System.out.println("Sorted List: " + namesList);

        // Binary search करना
        Name searchName = new Name("John");
        int index = Collections.binarySearch(namesList, searchName);
        System.out.println("John का Index: " + index);

        // गैर-मौजूदा नाम के लिए खोज करना
        Name nonExisting = new Name("john"); // Case-sensitive search
        int negativeIndex = Collections.binarySearch(namesList, nonExisting);
        System.out.println("john का Index: " + negativeIndex);
    }
}
			
				
					
				
					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
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
				
						import java.util.*;
 
class Name implements Comparable<Name> {
    private String name;
 
    public Name(String name) {
        this.name = name;
    }
 
    public String getName() {
        return name;
    }
 
    // Meaningful output के लिए toString को ओवरराइड करना
    @Override
    public String toString() {
        return this.name;
    }
 
    // 'name' field के आधार पर Name objects की तुलना के लिए equals को ओवरराइड करना
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
 
        Name name1 = (Name) o;
 
        return name != null ? name.equals(name1.name) : name1.name == null;
    }
 
    // equals के साथ मेल खाने के लिए hashCode को ओवरराइड करना
    @Override
    public int hashCode() {
        return name != null ? name.hashCode() : 0;
    }
 
    // 'name' के आधार पर natural ordering के लिए Comparable को implement करना
    @Override
    public int compareTo(Name o) {
        return this.name.compareTo(o.getName());
    }
}
 
public class CustomObjectCollection {
    public static void main(String[] args) {
        // Name objects का Set बनाना
        Set<Name> namesSet = new HashSet<>();
        namesSet.add(new Name("John"));
        namesSet.add(new Name("Afia"));
        namesSet.add(new Name("Chand"));
        namesSet.add(new Name("John")); // Duplicates, equals और hashCode के कारण ignore किया जाएगा
 
        System.out.println("Set Contents: " + namesSet);
 
        // Set को ordered operations के लिए List में बदलना
        List<Name> namesList = new ArrayList<>(namesSet);
        Collections.sort(namesList); // List को सॉर्ट करना
 
        System.out.println("Sorted List: " + namesList);
 
        // Binary search करना
        Name searchName = new Name("John");
        int index = Collections.binarySearch(namesList, searchName);
        System.out.println("John का Index: " + index);
 
        // गैर-मौजूदा नाम के लिए खोज करना
        Name nonExisting = new Name("john"); // Case-sensitive search
        int negativeIndex = Collections.binarySearch(namesList, nonExisting);
        System.out.println("john का Index: " + negativeIndex);
    }
}
					
				
			
		


Output:




		
		
			
			
Java
			
			Set Contents: [Afia, Chand, John]
Sorted List: [Afia, Chand, John]
John का Index: 2
john का Index: -4
			
				
					
				
					1
2
3
4
				
						Set Contents: [Afia, Chand, John]
Sorted List: [Afia, Chand, John]
John का Index: 2
john का Index: -4
					
				
			
		


मुख्य बिंदु

Data Integrity: equals और hashCode को ओवरराइड करने से collections objects को सही ढंग से संभालती हैं।
Natural Ordering: Comparable को implement करने से sorting और searching operations में सहूलियत मिलती है।
Avoid Common Pitfalls: इन methods की सही implementation से subtle bugs से बचा जा सकता है और collections में predictable behavior सुनिश्चित होता है।


निष्कर्ष
Java Collections, विशेष रूप से Sets और Lists में महारत हासिल करना प्रभावी और मजबूत Java applications बनाने के लिए मूलभूत है। Sets का उपयोग करके duplicates को समाप्त करना, Sets और Lists के बीच conversion करना, डेटा को कुशलतापूर्वक सॉर्ट करना, और binary search जैसे प्रभावी search algorithms को लागू करना डेवलपर्स को performance और maintainability के लिए अपने code को optimize करने में मदद करता है।
इसके अलावा, collections में custom objects के साथ काम करने के लिए equals, hashCode को ओवरराइड करने और Comparable interface को implement करने की स्पष्ट समझ आवश्यक है, जिससे डेटा की अखंडता सुनिश्चित होती है और seamless operations को सुविधाजनक बनाया जाता है। ये practices ना केवल Java applications की functionality को बढ़ाते हैं बल्कि code को cleaner और अधिक readable भी बनाते हैं।
मुख्य बिंदु

Sets vs. Lists: Sets को unique elements के लिए और Lists को ordered, indexed collections के लिए उपयोग करें।
Conversion: Sets और Lists के बीच आसानी से convert करें ताकि दोनों की ताकतों का लाभ उठाया जा सके।
Sorting and Searching: Collections.sort() और Collections.binarySearch() का उपयोग करके efficient data manipulation करें।
Custom Objects: equals, hashCode को सही ढंग से ओवरराइड करें, और Comparable को implement करें ताकि collections के साथ seamless काम किया जा सके।

इन concepts को अपनाने से आप डेटा को अधिक प्रभावी ढंग से संभाल सकते हैं, जिससे उच्च गुणवत्ता वाली Java applications विकसित करना आसान हो जाता है।
Keywords: Java Collections, Set, List, binary search, Collections.sort, Comparable interface, equals and hashCode, Java programming, data structures, ArrayList, HashSet, sorting algorithms, searching algorithms, custom objects in Java, data integrity, Java tutorials, efficient coding in Java

Note: यह लेख AI द्वारा जनरेट किया गया है।
S11L14 – कुछ और चीजें – खंड समापन

Java Collections में महारत: Sets, Lists, और कुशल खोज

विषय सूची

परिचय

Java Sets को समझना

Set क्या है?

Sets की प्रमुख विशेषताएँ

आम Set implementations

Set का उपयोग कब करें?

Sets के उपयोग के फायदे और नुकसान

Set को List में बदलना

Set को List में क्यों बदलें?

Step-बाय-Step Conversion

Code Example

मुख्य बिंदु

Java में Lists को सॉर्ट करना

Sorting का महत्व

Strings की List को सॉर्ट करना

Custom Objects की List को सॉर्ट करना

Comparable को लागू करना

Code Example

मुख्य बिंदु

Binary Search को लागू करना

Binary Search क्या है?

Binary Search के लिए आवश्यकताएँ

Java में Binary Search करना

Output को समझना

Custom Objects के साथ Code Example

मुख्य बिंदु

Collections में Custom Objects के साथ काम करना

`equals` और `hashCode` को ओवरराइड करने का महत्व

`equals` और `hashCode` को implement करना

Set में Custom Objects का उपयोग करना

Comparable Interface को Implement करना

आम गलतियां और उन्हें कैसे बचें

Comments के साथ Code Example

मुख्य बिंदु

निष्कर्ष

मुख्य बिंदु

फायदे	नुकसान
तत्वों की अनूठीता सुनिश्चित करता है	तत्वों के क्रम पर नियंत्रण नहीं
आमतौर पर तेज प्रदर्शन प्रदान करता है	Lists की तुलना में उच्च मेमोरी खपत
गणितीय सेट ऑपरेशंस के लिए उपयुक्त	Lists की तुलना में सीमित इंटरफेस