LinkedHashMaps qui ne sont pas dans l'ordre exact

Question

J'ai deux cartes qui ressemblent à ceci:

{PERSON=[Jack Fisher], ORGANIZATION=[Oriole, American League]} 
{LOCATION=[Oriole], PERSON=[Jack Fisher]} 

Je dois les comparer et incrémenter des compteurs pour une correspondance exacte, Match partielle et aucune correspondance. Je suis en train d'itérer sur ces deux cartes et leurs valeurs, mais comme elles ne sont pas en règle, mes comptes sont tous foirés. Est-il possible de comparer ces cartes? Si ce n'est pas le cas, y a-t-il une solution de contournement où je les mets en ordre et comparons ensuite. Et comment puis-je les mettre dans l'ordre exact?

EDIT - CODE AJOUT

private static List<Integer> compareMaps(LinkedHashMap<String, List<String>> annotationMap, 
     LinkedHashMap<String, List<String>> rageMap) { 
    List<Integer> compareResults = new ArrayList<Integer>(); 
    int i_index = 0; 
    for (Entry<String, List<String>> entry : annotationMap.entrySet()) { 
     if (rageMap.entrySet().isEmpty()) { 
      orgFalseNegativeCount++; 
      continue; 
     } 
     for (Entry<String, List<String>> rageEntry : rageMap.entrySet()) { 

      if (entry.getKey().equals("ORGANIZATION")) { 
       for (String val : entry.getValue()) { 
        recusion: for (int i = i_index; i < rageEntry.getValue().size();) { 
         String rageVal = rageEntry.getValue().get(i); 
         if (val.equals(rageVal)) { 
          orgTruePositiveCount++; 
          i_index++; 
          break recusion; 
         } 

         else if ((val.length() > rageVal.length()) && val.contains(rageVal)) { // || 
                           // dataB.get(entryA.getKey()).contains(entryA.getValue())){ 
          orgTruePositiveCount++; 
          i_index++; 
          break recusion; 
         } else if ((val.length() < rageVal.length()) && rageVal.contains(val)) { 
          orgTruePositiveCount++; 
          i_index++; 
          break recusion; 
         } 

         else if (!val.contains(rageVal)) { 
          orgFalseNegativeCount++; 
          i_index++; 
          break recusion; 
         } else if (!rageVal.contains(val)) { 
          orgFalsePositiveCount++; 
          i_index++; 
          break recusion; 
         } 

        } 
       } 
      } 

      if (entry.getKey().equals("PERSON")) { 
       for (String val : entry.getValue()) { 
        recusion: for (int i = i_index; i < rageEntry.getValue().size();) { 
         String rageVal = rageEntry.getValue().get(i); 

         if (val.equals(rageVal)) { 
          perTruePositiveCount++; 
          i_index++; 
          break recusion; 
         } 

         else if ((val.length() > rageVal.length()) && val.contains(rageVal)) { 
          perTruePositiveCount++; 
          i_index++; 
          break recusion; 
         } 

         else if ((val.length() < rageVal.length()) && rageVal.contains(val)) { 
          perTruePositiveCount++; 
          i_index++; 
          break recusion; 
         } 

         else if (!val.contains(rageVal)) { 
          perFalseNegativeCount++; 
          i_index++; 
          break recusion; 
         } 

         else if (!rageVal.contains(val)) { 
          perFalsePositiveCount++; 
          i_index++; 
          break recusion; 
         } 

        } 
       } 
      } 
     } 
    } 
} 

Answer 1

Vous pouvez utiliser SortedMap<K,V> et TreeMap<K,V> comme ça:

SortedMap<String, List<String>> left = new TreeMap<>(); 
SortedMap<String, List<String>> right = new TreeMap<>(); 
left .addAll(annotationMap); 
right.addAll(rageMap); 
compare(left, right); 

Pour comparer les listes que vous pouvez utiliser this answer.