Computer >> कंप्यूटर ट्यूटोरियल >  >> प्रोग्रामिंग >> Java

मान द्वारा Map सॉर्ट करने के लिए Java प्रोग्राम


इस लेख में, हम समझेंगे कि मान द्वारा मैप को कैसे सॉर्ट करें। Java HashMap Java के Map इंटरफेस की हैश टेबल आधारित कार्यान्वयन है। यह कुंजी-मान जोड़े का संग्रह है।

नीचे इसका प्रदर्शन है:

मान लीजिए हमारा इनपुट है:

इनपुट HashMap: कुंजी = Java, मान = 45
कुंजी = Scala, मान = 20
कुंजी = Mysql, मान = 11
कुंजी = Python, मान = 75

वांछित आउटपुट होगा:

सॉर्टिंग के बाद HashMap:
कुंजी = Mysql, मान = 11
कुंजी = Scala, मान = 20
कुंजी = Java, मान = 45
कुंजी = Python, मान = 75

एल्गोरिदम

चरण 1 - शुरू
चरण 2 - घोषित करें
चरण 3 - मान परिभाषित करें
चरण 4 - मैप के एलिमेंट्स को सॉर्ट करने के लिए 'sort' मेथड का उपयोग करें
चरण 5 - 'getValue' मेथड का उपयोग करके मान प्राप्त करें और दो मानों की तुलना के लिए 'compareTo' मेथड का उपयोग करें
चरण 6 - HashMap के माध्यम से इटरेट करें, और 'getKey' मेथड का उपयोग करके मानों को 'temp' में प्राप्त करें। 'temp' को रिटर्न मान के रूप में उपयोग करें।
चरण 7 - परिणाम प्रदर्शित करें
चरण 8 - रुकें

उदाहरण 1

यहाँ, हम सभी ऑपरेशन्स को 'main' फंक्शन के तहत बांधते हैं।

import java.util.*;
import java.lang.*;

public class Demo {
    public static HashMap sort(HashMap input_map) {
        List> list = 
            new LinkedList>(input_map.entrySet());
        
        Collections.sort(list, new Comparator>() {
            public int compare(Map.Entry o1,
                              Map.Entry o2) {
                return (o1.getValue()).compareTo(o2.getValue());
            }
        });
        
        HashMap temp = new LinkedHashMap();
        for (Map.Entry aa : list) {
            temp.put(aa.getKey(), aa.getValue());
        }
        return temp;
    }
    
    public static void main(String[] args) {
        HashMap input_map = new HashMap();
        input_map.put("Java", 45);
        input_map.put("Scala", 20);
        input_map.put("Mysql", 11);
        input_map.put("Python", 75);
        
        System.out.println("HashMap परिभाषित है:");
        for (Map.Entry element : input_map.entrySet()) {
            System.out.println("कुंजी = " + element.getKey() + ", मान = " + element.getValue());
        }
        
        Map result_map = sort(input_map);
        System.out.println("\nसॉर्टिंग के बाद HashMap है:");
        for (Map.Entry element : result_map.entrySet()) {
            System.out.println("कुंजी = " + element.getKey() + ", मान = " + element.getValue());
        }
    }
}

आउटपुट

HashMap परिभाषित है:
कुंजी = Java, मान = 45
कुंजी = Scala, मान = 20
कुंजी = Mysql, मान = 11
कुंजी = Python, मान = 75
सॉर्टिंग के बाद HashMap है:
कुंजी = Mysql, मान = 11
कुंजी = Scala, मान = 20
कुंजी = Java, मान = 45
कुंजी = Python, मान = 75

उदाहरण 2

यहाँ, हम ऑपरेशन्स को फंक्शन्स में एनकैप्सुलेट करते हैं जो ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग प्रदर्शित करते हैं।

import java.util.*;
import java.lang.*;

public class Demo {
    public static void main(String[] args) {
        HashMap input_map = new HashMap();
        input_map.put("Java", 45);
        input_map.put("Scala", 20);
        input_map.put("Mysql", 11);
        input_map.put("Python", 75);
        
        System.out.println("HashMap परिभाषित है:");
        for (Map.Entry element : input_map.entrySet()) {
            System.out.println("कुंजी = " + element.getKey() + ", मान = " + element.getValue());
        }
        
        List> list = 
            new LinkedList>(input_map.entrySet());
        
        Collections.sort(list, new Comparator>() {
            public int compare(Map.Entry o1,
                              Map.Entry o2) {
                return (o1.getValue()).compareTo(o2.getValue());
            }
        });
        
        HashMap result_map = new LinkedHashMap();
        for (Map.Entry aa : list) {
            result_map.put(aa.getKey(), aa.getValue());
        }
        
        System.out.println("\nसॉर्टिंग के बाद HashMap है:");
        for (Map.Entry element : result_map.entrySet()) {
            System.out.println("कुंजी = " + element.getKey() + ", मान = " + element.getValue());
        }
    }
}

आउटपुट

HashMap परिभाषित है:
कुंजी = Java, मान = 45
कुंजी = Scala, मान = 20
कुंजी = Mysql, मान = 11
कुंजी = Python, मान = 75
सॉर्टिंग के बाद HashMap है:
कुंजी = Mysql, मान = 11
कुंजी = Scala, मान = 20
कुंजी = Java, मान = 45
कुंजी = Python, मान = 75

आधुनिक Java 8+ दृष्टिकोण

// Stream API का उपयोग करके - सबसे पठनीय
Map sorted = input_map.entrySet().stream()
    .sorted(Map.Entry.comparingByValue())
    .collect(Collectors.toMap(
        Map.Entry::getKey,
        Map.Entry::getValue,
        (e1, e2) -> e1,
        LinkedHashMap::new  // इंसर्शन ऑर्डर संरक्षित करता है
    ));

// डिसेंडिंग ऑर्डर
Map sortedDesc = input_map.entrySet().stream()
    .sorted(Map.Entry.comparingByValue().reversed())
    .collect(Collectors.toMap(
        Map.Entry::getKey,
        Map.Entry::getValue,
        (e1, e2) -> e1,
        LinkedHashMap::new
    ));

// मेथड रेफरेंस के साथ
Map sorted = input_map.entrySet().stream()
    .sorted(Comparator.comparing(Map.Entry::getValue))
    .collect(Collectors.toMap(
        Map.Entry::getKey,
        Map.Entry::getValue,
        (e1, e2) -> e1,
        LinkedHashMap::new
    ));

महत्वपूर्ण बिंदु

  • LinkedHashMap: इंसर्शन ऑर्डर बनाए रखता है, सॉर्टेड मैप के लिए आवश्यक
  • HashMap: कोई ऑर्डर गारंटी नहीं, सॉर्टिंग के बाद उपयोग न करें
  • TreeMap: कुंजी द्वारा सॉर्टेड, मान द्वारा नहीं
  • डुप्लिकेट मान: मर्ज फंक्शन (e1, e2) -> e1 पहली घटना को रखता है
  • Null मान: comparingByValue() null मानों के साथ NPE फेंक सकता है

प्रदर्शन तुलना

तरीकासमय जटिलतास्पेसपठनीयता
Collections.sort + ListO(n log n)O(n)मध्यम
Stream APIO(n log n)O(n)उच्च
TreeMap (कुंजी द्वारा)O(n log n)O(n)उच्च
  1. - काउंटिंग सॉर्ट के लिए जावा प्रोग्राम

    काउंटिंग सॉर्ट विशिष्ट कुंजी मानों वाली वस्तुओं की संख्या गिनता है। आइए एक उदाहरण देखें: नोट - नीचे दिया गया कोड नेगेटिव नंबरों के साथ भी उपयोग किया जा सकता है। उदाहरण import java.util.*; public class Demo{ static void count_sort(int[] arr){ int max_val = Arrays.stream(arr).max().ge

  1. - बाइनरी इंसर्शन सॉर्ट के लिए जावा प्रोग्राम

    बाइनरी इंसर्शन सॉर्ट हर पुनरावृति पर एक विशिष्ट इंडेक्स पर एक एलिमेंट डालने के लिए सही स्थिति खोजने के लिए बाइनरी सर्च का उपयोग करता है। पहले, वह स्थान ढूंढा जाता है जहां एलिमेंट डाला जाना है। फिर, एलिमेंट्स को अगले राइट स्थान पर शिफ्ट किया जाता है। अब, विशिष्ट एलिमेंट को स्थिति में रखा जाता है। बा

  1. - कॉकटेल सॉर्ट के लिए जावा प्रोग्राम

    कॉकटेल सॉर्ट बबल सॉर्ट के विपरीत काम करता है, जिसमें एलिमेंट्स को बाएं से दाएं पुनरावृति किया जाता है, और सबसे बड़ा एलिमेंट पहले अपनी सही स्थिति में लाया जाता है और इसी तरह। कॉकटेल सॉर्ट में, एलिमेंट्स को वैकल्पिक क्रम में दोनों दिशाओं (बाएं और दाएं) में पुनरावृति किया जाता है। कॉकटेल सॉर्ट के लिए