Speichern einer HashMap in einer HashMap und Verbesserung der Leistung

Ich soll erstellt, um eine HashMap in einem anderen HashMap wie unten gezeigt, die ein speichern kann der Wert innerhalb der inneren HashMap basiert auf dem Schlüssel des äußeren HashMap zur Laufzeit

d.h. erforderliche Leistung für das Programm sollte im format

   { 1 = {11 = "aaa",15 = "bbb"}, 2 = {13 = "ccc", 14 = "ddd"} }

wo 1,2 sind Schlüssel-Werte für die Äußere HashMap.

Unten ist der Code für ihn Ist es der bessere Ansatz ist, um die Leistung zu verbessern

HashMap<Integer, HashMap<Integer, String>>Outer 
                   = new HashMap<Integer, HashMap<Integer,String>>();

    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    int count = Integer.parseInt(br.readLine());
    for(int i =0;i<count;i++)
    {
        String input[] = br.readLine().split("\\s");

        //HashMap<Integer,String>inner = new HashMap<Integer, String>();
        int key = Integer.parseInt(input[0]);
        if(Outer.isEmpty() || !Outer.containsKey(key))
        {
            HashMap<Integer, String> inner = new HashMap<Integer, String>();
            inner.put(Integer.parseInt(input[1]),input[2]);
            Outer.put(key, inner);
        }
        else if(Outer.containsKey(key))
            {
                HashMap<Integer, String> inner = (HashMap<Integer, String>) Outer.get(key).clone();
                inner.put(Integer.parseInt(input[1]), input[2]);
                Outer.put(key, inner);
            }
    }
Warum denken Sie, dass Sie benötigen, um die Leistung zu verbessern? Ist dieser code unter eine außerordentliche Menge an Zeit ausführen?
Ich denke, mit einem zwei-Niveau hashmap ist eher die Leistung reduzieren als Sie zu erhöhen.
Während es ist nicht klar, es könnte sein, ausgegangen von der Frage, dass die Aufspaltung in 2-Karten, die nicht aus Gründen der Leistung. Beachten Sie, dass die Bestimmung, für die äußere Karte ist aus dem gelesen werden die input - und nicht einen anderen berechneten hash. Ich denke, die Frage zielt auf die Verbesserung der Leistung der vorliegenden Implementierung erfordert die Verwendung von verschachtelten maps.
Erstens vielen Dank an alle für die Antworten. Ich war die Implementierung der gleichen Funktion zum extrahieren dieser datastructure um eine prefetch-Daten aus der Datenbank und die Anzahl der Elemente, die für die innere Hashmap erhöht es verursacht Verzögerung als Klon ist eine vordefinierte Methode von java, die nicht twicked also ich wollte wissen, ob kann es einige andere bessere Ansatz, anstatt abhängig von vordefinierten Methode von java
Wenn Ihr zwei-level-HashMap ist nicht erforderlich, Ihre Daten-Modell, aber nur in einem Versuch für die Leistung - ich Stimme mit Tom - es gibt noch mehr overhead hier, und Sie wären besser dran mit einem einzigen HashMap. Ich bin mir nicht sicher, wie Sie Sie clone() bezieht sich auf diese Diskussion, wie Sie gar nicht brauchen. Die absolute beste, was Sie vermutlich tun können, um Leistung zu erhöhen, da die zusätzlichen details, die Sie nur zur Verfügung gestellt, ist die Initialisierung der HashMap mit einer erwarteten Kapazität, z.B. new HashMap(5000). Wenn Sie einen richtigen Wert gewählt wird, wird dies verhindern, dass die Größe, wie Sie wahrscheinlich beobachtet.

InformationsquelleAutor cryptonkid | 2012-01-14

  1. 2

    Ähnlich Vadim Antwort, aber weiter verbessert, als es nicht erforderlich, einen Aufruf an beide containsKey sowie get:

    Map<Integer, Map<Integer, String>> outer = new HashMap<Integer, Map<Integer, String>>();
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int count = Integer.parseInt(br.readLine());

Pattern splitter = Pattern.compile("\\s");

for(int i = 0; i < count; i++){
    String input[] = splitter.split(br.readLine());

    int key = Integer.parseInt(input[0]);

    Map<Integer, String> inner = outer.get(key);
    if(inner == null){
        inner = new HashMap<Integer, String>();
        outer.put(key, inner);
    }
    inner.put(Integer.parseInt(input[1]), input[2]);
}

    Es hat auch einige kleine Verbesserungen für die Namenskonventionen und Verwendung der Sammlungen-Schnittstellen anstelle von konkreten Typen.

    Ich auch entfernt den Aufruf clone. Dies könnte eine leichte Spar - und ich glaube nicht, es würde gegeben haben Sie Ihre erwarteten Ergebnisse.

    Endlich - eine andere Sache, die ich geändert habe, das könnte eine leichte Verbesserung ist die Verwendung eines vorkompilierten Muster für die Aufteilung der Zeichenkette in Felder.

    Dank ziesemer tolle Tipps zu zwicken

    InformationsquelleAutor ziesemer

  2. 1

    Optimierung ist fast immer eine schlechte Idee. Besonders in Java, wo die JVM ist sehr gut macht das von selbst.

    Brauchen Sie wirklich eine Map<Integer, Map<Integer, String>> es scheint mir, dass Sie wirklich brauchen nur ein Map<Pair, String> wo

    public final class Pair {
  private final int x;
  private final int y;
  public Pair(int x, int y) { this.x = x; this.y = y;}
}

    Ich behaupte nicht, dass dies die Leistung zu verbessern, aber es könnte besser sein, design. Ich weiß nicht ganz, was Sie tun, so ist es vielleicht nicht besser zu gestalten.

    Ich hatte eine Ahnung, dass dies der richtige Weg ist. Also suchte ich nach der "falschen Fragen" zu stellen und als ich hier ankam. Ich habe verwendet, Objekte mit Hashmaps die dann in ein anderes Objekt. Ich war mir nicht sicher, ob das gut war, zu üben und Ihre Antworten helfen, um zu bestätigen, dass die Erschließung OOP ist der Weg zu gehen.
    By the way, stellen Sie sicher, dass Sie eine unveränderliche Objekt als Schlüssel zu einer Karte. Die Karte verwendet die hash, der das Objekt als der eigentliche Schlüssel. Wenn Ihr Objekt ist veränderlich, verändert das Objekt wird wahrscheinlich auf die Raute und Sie werden nicht in der Lage zu finden, etwas mehr in die Karte.
    Ich habe generierten hashcode und equals für Objekte zu identifizieren, die Einzigartigkeit, wird das helfen? Ich bin nicht sicher, ob ich tun kann, unveränderlich obwohl, das wäre ideal.
    Ja das könnte helfen. Aber wahrscheinlich wird das Standard-hashCode und equals ausreichend waren. Seien Sie vorsichtig, wenn Sie es nicht schaffen, unveränderlich und stellen Sie sicher, dass Sie nie ändern Sie eine beliebige Taste, Objekte nach dem einfügen in die map.
    thanks a lot mate 🙂

    InformationsquelleAutor toto2

  3. 0

    Dein code gut genug aus performance-Sicht.
    Nur wenige Dinge, die mir in den Sinn kam. If/else-Bedingung kann vereinfacht werden, und Sie brauchen nicht zu Klonen Karte im else-Teil (Arbeit mit Zeiger) 

    HashMap<Integer, HashMap<Integer, String>>Outer = new HashMap<Integer,   HashMap<Integer,String>>();
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int count = Integer.parseInt(br.readLine());
for(int i =0;i<count;i++)
{
    String input[] = br.readLine().split("\\s");

    //HashMap<Integer,String>inner = new HashMap<Integer, String>();
    int key = Integer.parseInt(input[0]);
    if(!Outer.containsKey(key))
    {
        HashMap<Integer, String> inner = new HashMap<Integer, String>();
        inner.put(Integer.parseInt(input[1]),input[2]);
        Outer.put(key, inner);
    }
    else
    {
        HashMap<Integer, String> inner = Outer.get(key);
        inner.put(Integer.parseInt(input[1]), input[2]);
    }
}
    Vielen Dank für Sie Tipps vadim 🙂 Große Hilfe in der Tat

    InformationsquelleAutor Vadim Gulyakin

Schreibe einen Kommentar