Wie man den maximalen Wert in einer Map findet

Einführung

In Java ist die Map-Datenstruktur (Kartendatenstruktur) eine Schnittstelle, die Daten in Schlüssel-Wert-Paaren speichert. Im Gegensatz zu Arrays oder Listen behalten Maps nicht die Einfügereihenfolge bei, was das Finden des maximalen Werts schwieriger macht. In diesem Lab werden Sie durch verschiedene Ansätze geführt, um den maximalen Wert in einer Map zu finden, eine häufige Aufgabe in Datenverarbeitungsanwendungen.

Sie werden zwei Hauptmethoden lernen:

• Der iterative Ansatz unter Verwendung einer Schleife, um alle Werte zu vergleichen
• Der integrierte Ansatz unter Verwendung der Collections-Hilfsklasse

Am Ende dieses Labs werden Sie verstehen, wie Sie effizient Extreme werte in Java-Maps finden können, eine essentielle Fähigkeit für Datenmanipulationstasks.

Skills Graph

Verständnis und Erstellung einer Java-Map

Die Map-Schnittstelle (Kartenschnittstelle) in Java wird verwendet, um Schlüssel-Wert-Paare zu speichern, wobei jeder Schlüssel eindeutig ist. In diesem Schritt werden wir eine einfache Map erstellen, die Kursnamen als Schlüssel und die entsprechenden Preise als Werte speichert.

Was ist eine Map in Java?

Eine Map in Java:

• Enthält Schlüssel-Wert-Paare
• Kann keine doppelten Schlüssel enthalten
• Jeder Schlüssel kann auf höchstens einen Wert verweisen
• Häufig verwendete Implementierungen sind HashMap, TreeMap und LinkedHashMap

Beispiel für die Erstellung einer Java-Map

Erstellen wir eine Datei in der WebIDE, um eine Map zu demonstrieren:

1. Erstellen Sie in der WebIDE eine neue Datei mit dem Namen MaxValueInMap.java
2. Kopieren Sie den folgenden Code in die Datei:

import java.util.*;

public class MaxValueInMap {
    public static void main(String args[]) {
        // Create a HashMap to store course prices
        Map<String, Integer> coursePrice = new HashMap<>();

        // Add key-value pairs to the map
        coursePrice.put("Java", 5000);
        coursePrice.put("Python", 3000);
        coursePrice.put("CPP", 4000);
        coursePrice.put("Android", 8000);

        // Print the entire map
        System.out.println("Course price map: " + coursePrice);
    }
}

3. Speichern Sie die Datei, indem Sie auf "Datei" > "Speichern" klicken oder Strg+S drücken.

4. Öffnen Sie ein Terminal in der WebIDE und führen Sie den folgenden Befehl aus, um das Programm zu kompilieren und auszuführen:

javac MaxValueInMap.java && java MaxValueInMap

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Course price map: {Java=5000, CPP=4000, Android=8000, Python=3000}

Beachten Sie, dass die Reihenfolge der Elemente möglicherweise von der Einfügereihenfolge abweicht. Dies liegt daran, dass HashMap keine bestimmte Reihenfolge der Elemente beibehält.

Finden des maximalen Werts mithilfe von Iteration

Eine Möglichkeit, den maximalen Wert in einer Map zu finden, besteht darin, alle Einträge zu durchlaufen und den bisher gefundenen maximalen Wert zu verfolgen. Dieser Ansatz funktioniert mit jeder Map-Implementierung.

Was ist Map.Entry?

Map.Entry ist eine Schnittstelle, die ein Schlüssel-Wert-Paar in einer Map darstellt. Sie bietet Methoden, um sowohl den Schlüssel als auch den Wert im Paar zuzugreifen.

Implementierung des iterativen Ansatzes

Ändern wir unser Java-Programm, um den maximalen Kurspreis mithilfe von Iteration zu finden:

1. Öffnen Sie die Datei MaxValueInMap.java in der WebIDE.

2. Ersetzen Sie den vorhandenen Code durch den folgenden:

import java.util.*;

public class MaxValueInMap {
    public static void main(String args[]) {
        // Create a HashMap to store course prices
        Map<String, Integer> coursePrices = new HashMap<>();

        // Variable to store the entry with maximum price
        Map.Entry<String, Integer> maxEntry = null;

        // Add key-value pairs to the map
        coursePrices.put("Java", 5000);
        coursePrices.put("Python", 3000);
        coursePrices.put("CPP", 4000);
        coursePrices.put("Android", 8000);

        System.out.println("Course price map: " + coursePrices);

        // Iterate through each entry in the map
        for (Map.Entry<String, Integer> entry : coursePrices.entrySet()) {
            // If maxEntry is null OR current entry's value is greater than maxEntry's value
            if (maxEntry == null || entry.getValue().compareTo(maxEntry.getValue()) > 0) {
                maxEntry = entry;
            }
        }

        // Print the maximum price and its corresponding course
        System.out.println("Course with maximum price: " + maxEntry.getKey());
        System.out.println("Maximum price: " + maxEntry.getValue());
    }
}

3. Speichern Sie die Datei.

4. Führen Sie das Programm aus mit:

javac MaxValueInMap.java && java MaxValueInMap

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Course price map: {Java=5000, CPP=4000, Android=8000, Python=3000}
Course with maximum price: Android
Maximum price: 8000

Wie die Iteration funktioniert

1. Wir erstellen eine Variable maxEntry, die zunächst auf null gesetzt wird.
2. Wir durchlaufen jeden Eintrag in der Map mithilfe der Methode entrySet().
3. Für jeden Eintrag vergleichen wir seinen Wert mit dem aktuellen maximalen Wert.
4. Wenn der aktuelle Eintrag einen größeren Wert hat oder wenn maxEntry immer noch null ist, aktualisieren wir maxEntry.
5. Nach Abschluss der Iteration enthält maxEntry den Eintrag mit dem maximalen Wert.

Dieser Ansatz ist nützlich, wenn Sie sowohl den Schlüssel als auch den Wert des maximalen Eintrags benötigen.

Finden des maximalen Werts mit Collections.max()

Java bietet eine kürzere Möglichkeit, den maximalen Wert in einer Sammlung zu finden, indem die Methode Collections.max() verwendet wird. Diese Methode kann auf jede Sammlung angewendet werden, einschließlich der Werte einer Map.

Verständnis von Collections.max()

Die Methode Collections.max():

• Nimmt eine Sammlung als Eingabe und gibt das maximale Element zurück.
• Nutzt die natürliche Sortierung der Elemente oder einen benutzerdefinierten Vergleicher (Comparator).
• Ist kürzer als der iterative Ansatz.
• Gibt nur den maximalen Wert zurück, nicht den zugehörigen Schlüssel.

Implementierung von Collections.max() für Map-Werte

Ändern wir unser Programm, um Collections.max() zu verwenden:

1. Öffnen Sie die Datei MaxValueInMap.java in der WebIDE.

2. Ersetzen Sie den vorhandenen Code durch den folgenden:

import java.util.*;

public class MaxValueInMap {
    public static void main(String args[]) {
        // Create a HashMap to store course prices
        Map<String, Integer> coursePrice = new HashMap<>();

        // Add key-value pairs to the map
        coursePrice.put("Java", 5000);
        coursePrice.put("Python", 3000);
        coursePrice.put("CPP", 4000);
        coursePrice.put("Android", 8000);

        System.out.println("Course price map: " + coursePrice);

        // Find maximum value using Collections.max()
        Integer maxPrice = Collections.max(coursePrice.values());

        System.out.println("Maximum price: " + maxPrice);

        // To find the key associated with the maximum value
        for (Map.Entry<String, Integer> entry : coursePrice.entrySet()) {
            if (entry.getValue().equals(maxPrice)) {
                System.out.println("Course with maximum price: " + entry.getKey());
                break;  // Exit the loop once we find the key
            }
        }
    }
}

3. Speichern Sie die Datei.

4. Führen Sie das Programm aus mit:

javac MaxValueInMap.java && java MaxValueInMap

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Course price map: {Java=5000, CPP=4000, Android=8000, Python=3000}
Maximum price: 8000
Course with maximum price: Android

Wie Collections.max() funktioniert

1. Die Methode coursePrice.values() gibt eine Ansicht (Collection view) aller Werte in der Map zurück.
2. Collections.max() findet das maximale Element in dieser Sammlung.
3. Anschließend durchlaufen wir die Map, um den Schlüssel zu finden, der diesem maximalen Wert zugeordnet ist.

Dieser Ansatz ist kürzer als die vorherige iterative Methode, erfordert aber einen zusätzlichen Schritt, um den zugehörigen Schlüssel zu finden.

Finden des maximalen Schlüssels in einer Map

Bisher haben wir uns darauf konzentriert, den maximalen Wert in einer Map zu finden. Manchmal müssen Sie jedoch stattdessen den maximalen Schlüssel finden. Dies ist üblich in Szenarien, in denen Schlüssel eine natürliche Sortierung haben und eine bedeutende Bedeutung haben.

Verständnis von Map-Schlüsseln vs. Werten

In einer Map:

• Schlüssel sind eindeutige Identifikatoren.
• Werte sind die Daten, die jedem Schlüssel zugeordnet sind.
• Schlüssel können sortiert werden, wenn sie das Comparable-Interface implementieren.
• Zum Finden des maximalen Schlüssels wird keySet() anstelle von values() verwendet.

Erstellen einer Map mit Preisen als Schlüsseln

Erstellen wir ein neues Beispiel, in dem Preise die Schlüssel und Kursnamen die Werte sind:

1. Öffnen Sie die Datei MaxValueInMap.java in der WebIDE.

2. Ersetzen Sie den vorhandenen Code durch den folgenden:

import java.util.*;

public class MaxValueInMap {
    public static void main(String args[]) {
        // Create a HashMap with prices as keys and course names as values
        Map<Integer, String> priceMap = new HashMap<>();

        // Add key-value pairs to the map
        priceMap.put(5000, "Java");
        priceMap.put(3000, "Python");
        priceMap.put(4000, "CPP");
        priceMap.put(8000, "Android");

        System.out.println("Price to course map: " + priceMap);

        // Find maximum key using Collections.max()
        Integer maxPrice = Collections.max(priceMap.keySet());

        System.out.println("Maximum price: " + maxPrice);
        System.out.println("Course with maximum price: " + priceMap.get(maxPrice));

        // Find minimum key using Collections.min()
        Integer minPrice = Collections.min(priceMap.keySet());

        System.out.println("Minimum price: " + minPrice);
        System.out.println("Course with minimum price: " + priceMap.get(minPrice));
    }
}

3. Speichern Sie die Datei.

4. Führen Sie das Programm aus mit:

javac MaxValueInMap.java && java MaxValueInMap

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Price to course map: {3000=Python, 4000=CPP, 5000=Java, 8000=Android}
Maximum price: 8000
Course with maximum price: Android
Minimum price: 3000
Course with minimum price: Python

Wesentliche Unterschiede in diesem Ansatz

1. Die Map-Struktur ist umgekehrt: Preise sind jetzt Schlüssel, und Kursnamen sind Werte.
2. Wir verwenden keySet() anstelle von values(), um alle Schlüssel zu erhalten.
3. Wir können direkt auf den entsprechenden Wert zugreifen, indem wir get(maxPrice) verwenden.
4. Wir haben auch ein Beispiel für das Finden des minimalen Preises mit Collections.min() hinzugefügt.

Dieser Ansatz ist nützlich, wenn die numerischen Werte, die Sie vergleichen möchten, bereits als Schlüssel in Ihrer Map verwendet werden.

Zusammenfassung

In diesem Lab haben Sie mehrere Methoden kennengelernt, um maximale Werte in Java-Maps zu finden:

1. Iterativer Ansatz: Verwenden von Schleifen, um durch die Map-Einträge zu iterieren und die Werte zu vergleichen.

   • Liefert sowohl den maximalen Wert als auch den zugehörigen Schlüssel.
   • Funktioniert mit jeder Map-Implementierung.
   • Nützlich für benutzerdefinierte Vergleichslogik.

2. Collections.max() für Werte: Verwenden des integrierten Collections-Hilfsprogramms, um den maximalen Wert zu finden.

   • Kürzerer Code als der iterative Ansatz.
   • Erfordert zusätzliche Schritte, um den zugehörigen Schlüssel zu finden.
   • Nutzt die natürliche Sortierung der Elemente.

3. Collections.max() für Schlüssel: Finden des maximalen Schlüssels in einer Map.

   • Nützlich, wenn Schlüssel sinnvolle numerische Werte haben.
   • Direkter Zugriff auf den zugehörigen Wert über get().
   • Kann auch mit Collections.min() verwendet werden, um minimale Werte zu finden.

Diese Techniken werden häufig in Datenverarbeitungsanwendungen, bei der Verarbeitung von Datenbankergebnissen, bei statistischen Berechnungen und in vielen anderen Programmier-Szenarien eingesetzt, die das Finden von Extremwerten in Datensammlungen betreffen.

Wenn Sie weiterhin mit Java-Sammlungen arbeiten, denken Sie daran, dass der von Ihnen gewählte Ansatz von Ihren spezifischen Anforderungen abhängen sollte, einschließlich davon, ob Sie den Schlüssel, den Wert oder beides benötigen und ob Sie benutzerdefinierte Vergleichslogik benötigen.