Comparator qui peut comparer LinkedHashMaps

Question

Je suis nouveau à Comparators en Java

Quelqu'un peut-il me aider à créer un Comparator pour comparer LinkedHashmaps en comparant les clés/valeurs?

Answer 1

Voici un exemple de pseudo-code. Il ne gère pas les valeurs nulles (qui peuvent être ajoutées si vous le souhaitez) et compare Map et une carte ne sera pas très différente/difficile :). Il y a un cas de test et beaucoup de lignes gaspillées pour réellement mettre en place une liste de cartes, mais devrait être facile à suivre.

package com.ekanathk; 

import static org.junit.Assert.*; 

import java.util.ArrayList; 
import java.util.Collections; 
import java.util.Comparator; 
import java.util.LinkedHashMap; 
import java.util.List; 
import java.util.Map; 

import org.junit.Test; 

class MapEntryComparator implements Comparator<Map<String, String>> { 

    private String[] keysToCompare; 

    //What are the key columns you want to compare ??? 
    public MapEntryComparator(String[] keysToCompare) { 
     this.keysToCompare = keysToCompare; 
    } 

    @Override 
    public int compare(Map<String, String> o1, Map<String, String> o2) { 
     for(String s: keysToCompare) { 
      //HANDLE NULLS if any 
      int comparison = o1.get(s).compareTo(o2.get(s)); 
      if(comparison != 0) { 
       return comparison; 
      } 
     } 
     return 0; 
    } 

} 
public class ComparatorCheck { 

    @Test 
    public void testSimple() { 
     LinkedHashMap<String, String> m1 = getMapSample("X", "M", "C", "D"); 
     LinkedHashMap<String, String> m2 = getMapSample("A", "B", "C", "D"); 
     LinkedHashMap<String, String> m3 = getMapSample("A", "B", "C", "D"); 
     LinkedHashMap<String, String> m4 = getMapSample("A", "B", "X", "D"); 

     List<LinkedHashMap<String, String>> list = new ArrayList<LinkedHashMap<String,String>>(); 
     list.add(m1); 
     list.add(m2); 
     list.add(m3); 
     list.add(m4); 

     MapEntryComparator comparator = new MapEntryComparator(new String[]{"k1", "k2", "k3"}); 

     Collections.sort(list, comparator); 

     assertEquals(m2, list.get(0)); 
     assertEquals(m3, list.get(1)); 
     assertEquals(m4, list.get(2)); 
     assertEquals(m1, list.get(3)); 
    } 

    private LinkedHashMap<String, String> getMapSample(String v1, String v2, String v3, String v4) { 
     LinkedHashMap<String, String> map = new LinkedHashMap<String, String>(); 
     map.put("k1", v1); 
     map.put("k2", v2); 
     map.put("k3", v3); 
     map.put("k4", v4); 
     return map; 
    } 
} 

Answer 2

je ferais quelque chose comme ceci: (psuedocode)

for(each entry in firstList) { 
    a=firstList.nextKey(); 
    b=secondList.nextKey(); 
    if(a != b !! firstList.get(a) != firstList.get(b)) 
     return false; 
} 
return true; 

mais cela implique que vous utilisez l'identité de l'objet (en d'autres termes, chaque objet doit être le même objet exact dans les deux listes).

Si ce n'est pas le cas, vous devez implémenter equals dans chaque objet unique qui pourrait être soit dans la liste, puis remplacez:

if(a != b ... 

avec

if(!a.equals(b)... 

ou quelque chose comme ça . De plus, comme quelqu'un l'a dit dans les commentaires, il y a de très bonnes chances qu'il y ait une meilleure façon de résoudre tout problème que vous essayez de résoudre.

Answer 3

Chaque Map (en fait, toutes les sous-classes de AbstractMap) a déjà mis en œuvre la méthode equals(..) d'une manière qui compare les paires clé/valeur.

Ainsi, si vous utilisez un Comparator, vous pouvez utiliser:

public int compare(Map first, Map second){ 
     // appropriate null checks here 
     return first.equals(second) ? 0 : 1; 
} 

---

Mais je préfère mettre les Map s dans une nouvelle HashSet, qui supprime automatiquement les doublons:

Set<Map> uniqueMaps = new HashSet<Map>(listOfMaps);