Comment créer une étiquette unique avec incrémentation des clés pour les doublons?

Question

Il s'agit d'un problème de technique de programmation dans le contexte de Java.

Problème: Nous avons des clés String qui doivent toutes être uniques. L'implémentation de la collection est une combinaison de Map et ArrayList qui permet d'utiliser la collection comme Map ou ArrayList (DefaultPieDataset de JFreeChart si vous êtes curieux). Si nous avons une seule donnée que nous voulons, c'est la clé d'être elle-même. Si nous avons des multiples qui sont séparés par une autre clé, nous voulons les données plus un séparateur et un nombre croissant.

Par exemple:

Les données avec deux entrées Bob puis un Albert aurait clés comme ["Bob", "Albert"].

données qui ressemble à Albert et Bob avec deux Bob entrées avec un Albert aurait entre clés comme ["Bob : 1", "Albert", "Bob : 2"].

Ceci est notre code jusqu'à présent:

String dataKey = ""; 
DefaultPieDataset ringDataset = new DefaultPieDataset(); 
for(String thisData: dataList) 
{ 
    int dataValue; 
    if(dataKey.equals(thisData)) 
    { 
     dataValue= ringDataset.getValue(dataKey).intValue() + 1; 
    }else 
    { 
     dataKey= thisData; 
     if(ringDataset.getKeys().contains(dataKey) || ringDataset.getKeys().contains(dataKey+ " : 1")) //has this name been represented already? 
     { 
      if(ringDataset.getKeys().contains(dataKey)) //do we need to change the name to accommodate multiples? 
      { 
       int existingKeyIndex = ringDataset.getIndex(dataKey); 
       int existingKeyValue = ringDataset.getValue(dataKey).intValue(); 
       ringDataset.remove(dataKey); 
       ringDataset.insertValue(existingKeyIndex, dataKey+ " : 1", existingKeyValue); 
      } 

      int counter = 2; 
      do{ 
       dataKey= thisData + " : " + counter; 
       counter ++; 
      }while(ringDataset.getKeys().contains(dataKey)); //ensure that we are using a new key 
     } 
     dataValue= 1; 
    } 
ringDataset.setValue(dataKey, dataValue); 
} 

Actuellement, les punaises de code sur la « # » pour chaque duplicata ainsi qu'au lieu de Bob : 2 il fait Bob : 1 : 2

Un ajouté défi est que je ne peut pas garantir que le nom n'aura pas le séparateur (deux points dans l'exemple).

De plus, il y a beaucoup de formalités administratives requises pour les bibliothèques ajoutées, donc une solution Java API seulement est nécessaire.

Merci d'aider à ce twister particulier du cerveau,
Adam

Edit: Pour clarifier le code d'une valeur de points est basé sur le nombre de fois que le type de données est venu dans une rangée. Dans le premier exemple, la clé Bob a une valeur de 2 et Albert 1. Dans le deuxième exemple, toutes les clés ont une valeur de 1.

Answer 1

Je suppose que vous n'avez pas besoin de gérer l'unicité d'un système distribué depuis votre problème est du côté du client. De plus, je suppose que vous n'avez pas à gérer la synchronisation sur plusieurs threads. Si ce n'est pas le cas, vous pouvez envisager de placer le mot-clé synchronized dans la méthode incrementLabelCount(), et la performance est probablement correcte.

Je briserai vos codes en deux parties, il est donc plus facile à gérer:
- partie 1: garder le suivi des étiquettes déjà connues - partie 2: générer l'étiquette unique

Ce qui suit est les codes Je tape juste rapidement (sans logique de compilation)

class KnownLabels 
{ 
    Map<String, Integer> currentCountsByLabel; 

    public int incrementLabelCount(String label) 
    { 
    Integer count = currentCountsByLabel.get(label); 
    if(count==null) 
     count = 1; 
    else 
     count += 1; 

    currentCountsByLabel.put(label, count); 

    return count; 
    } 
} 

class UniqueLabelGenerator 
{ 
    private KnownLabels knownLabels = new KnownLabels(); 

    public String getUniqueLabel(String label) 
    { 
    int i = knownLabels.incrementLabelCount(label); 

    if(i>1) 
     return label + ":" + i; 

    return label; 
    } 
}