Sortieren einer Kartenliste

Ich habe eine Listenvariable wie folgt erstellt:

List<Map<String, String>> list = new ArrayList<Map<String, String>>();

In meiner Android-Anwendung wird diese Liste ausgefüllt.

nur ein beispiel:

Map<String, String> map1 = new HashMap<String, String>();
map.put("name", "Josh");
...

Map<String, String> map2 = new HashMap<String, String>();
map.put("name", "Anna");
...

Map<String, String> map3 = new HashMap<String, String>();
map.put("name", "Bernie");
...

list.add(map1);
list.add(map2);
list.add(map3);

ich benutze list Ergebnisse in a anzeigen ListView durch Verlängerung BaseAdapter und Umsetzung der verschiedenen Methoden.

Mein Problem: Ich muss sortieren list in alphabetischer Reihenfolge basierend auf dem Schlüssel der Karte Name

Frage: Wie kann man einfach sortieren list in alphabetischer Reihenfolge basierend auf dem Schlüssel der Karte Name?

Ich kann mir das nicht vorstellen. Ich habe jeden extrahiert Name von jedem Map in ein String Array und sortierte es (Arrays.sort(strArray);). Aber das behält nicht die anderen Daten in jedem bei Map, daher bin ich mir nicht sicher, wie ich die anderen zugeordneten Werte beibehalten kann

Der folgende Code funktioniert einwandfrei

public Comparator<Map<String, String>> mapComparator = new Comparator<Map<String, String>>() {
    public int compare(Map<String, String> m1, Map<String, String> m2) {
        return m1.get("name").compareTo(m2.get("name"));
    }
}

Collections.sort(list, mapComparator);

Aber Ihre Maps sollten wahrscheinlich Instanzen einer bestimmten Klasse sein.

Sie sollten a . implementieren Comparator<Map<String, String>> was im Grunde den “name” -Wert aus den beiden übergebenen Maps extrahiert und sie vergleicht.

Dann benutze Collections.sort(list, comparator).

Bist du dir sicher Map<String, String> ist aber wirklich der beste Elementtyp für Ihre Liste? Vielleicht solltest du eine andere Klasse haben, die enthält ein Map<String, String> hat aber auch eine getName() Methode?

@Test
public void testSortedMaps() {
    Map<String, String> map1 = new HashMap<String, String>();
    map1.put("name", "Josh");

    Map<String, String> map2 = new HashMap<String, String>();
    map2.put("name", "Anna");

    Map<String, String> map3 = new HashMap<String, String>();
    map3.put("name", "Bernie");

    List<Map<String, String>> mapList = new ArrayList<Map<String, String>>();
    mapList.add(map1);
    mapList.add(map2);
    mapList.add(map3);

    Collections.sort(mapList, new Comparator<Map<String, String>>() {
        public int compare(final Map<String, String> o1, final Map<String, String> o2) {
            return o1.get("name").compareTo(o2.get("name"));
        }
    });

    Assert.assertEquals("Anna", mapList.get(0).get("name"));
    Assert.assertEquals("Bernie", mapList.get(1).get("name"));
    Assert.assertEquals("Josh", mapList.get(2).get("name"));

}

Sie müssen einen Komparator erstellen. Ich bin mir nicht sicher, warum jeder Wert eine eigene Karte benötigt, aber so würde der Komparator aussehen:

class ListMapComparator implements Comparator {
    public int compare(Object obj1, Object obj2) {
         Map<String, String> test1 = (Map<String, String>) obj1;
         Map<String, String> test2 = (Map<String, String>) obj2;
         return test1.get("name").compareTo(test2.get("name"));
    }
}

Sie können sehen, wie es mit Ihrem obigen Beispiel funktioniert:

public class MapSort {
    public List<Map<String, String>> testMap() {
         List<Map<String, String>> list = new ArrayList<Map<String, String>>();
         Map<String, String> myMap1 = new HashMap<String, String>();
         myMap1.put("name", "Josh");
         Map<String, String> myMap2 = new HashMap<String, String>();
         myMap2.put("name", "Anna");

         Map<String, String> myMap3 = new HashMap<String, String>();
         myMap3.put("name", "Bernie");


         list.add(myMap1);
         list.add(myMap2);
         list.add(myMap3);

         return list;
    }

    public static void main(String[] args) {
         MapSort ms = new MapSort();
         List<Map<String, String>> testMap = ms.testMap();
         System.out.println("Before Sort: " + testMap);
         Collections.sort(testMap, new ListMapComparator());
         System.out.println("After Sort: " + testMap);
    }
}

Sie werden einige typsichere Warnungen erhalten, da ich mir darüber keine Sorgen gemacht habe. Hoffentlich hilft das.

wenn Sie Lamdas verwenden und das Lesen etwas erleichtern möchten

  List<Map<String,String>> results;

  Comparator<Map<String,String>> sortByName = Comparator.comparing(x -> x.get("Name"));

  public void doSomething(){
    results.sort(sortByName)
  }

Nicht wirklich eine Antwort auf Ihre Frage, aber ich musste eine Liste von Karten nach den Eigenschaften ihrer Werte sortieren. Dies funktioniert auch in Ihrem Fall:

List<Map<String, Object>> sortedListOfMaps = someListOfMaps.sorted(Comparator.comparing(map -> ((String) map.get("someKey")))).collect(Collectors.toList()))

Etwas außerhalb des Themas
Dies ist ein kleines Util zum Ansehen von geteilten Einstellungen
basierend auf oberen Antworten
vielleicht ist das für jemanden hilfreich

@SuppressWarnings("unused")
public void printAll() {
    Map<String, ?> prefAll = PreferenceManager
        .getDefaultSharedPreferences(context).getAll();
    if (prefAll == null) {
        return;
    }
    List<Map.Entry<String, ?>> list = new ArrayList<>();
    list.addAll(prefAll.entrySet());
    Collections.sort(list, new Comparator<Map.Entry<String, ?>>() {
        public int compare(final Map.Entry<String, ?> entry1, final Map.Entry<String, ?> entry2) {
            return entry1.getKey().compareTo(entry2.getKey());
        }
    });
    Timber.i("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
    Timber.i("Printing all sharedPreferences");
    for(Map.Entry<String, ?> entry : list) {
        Timber.i("%s: %s", entry.getKey(), entry.getValue());
    }
    Timber.i("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
}