Comment puis-je former une liste ordonnée de valeurs extraites de HashMap ?

Question

Mon problème est en fait plus nuancé que ne le suggère la question, mais je voulais garder un en-tête bref.

j'ai un HashMap<String, File> de File des objets comme valeurs.Les clés sont String name domaines qui font partie du File instances.Je dois parcourir les valeurs dans le HashMap et renvoyez-les en un seul String.

Voilà ce que j'ai actuellement :

private String getFiles()
{   
    Collection<File> fileCollection = files.values();
    StringBuilder allFilesString = new StringBuilder();

    for(File file : fileCollection) {
        allFilesString.append(file.toString());
    }
    return allFilesString.toString();
}

Cela fait l'affaire, mais idéalement, je veux le séparé File valeurs à ajouter au StringBuilder dans l'ordre de int fileID, qui est un domaine du File classe.

J'espère avoir été assez clair.

Answer 1

Quelque chose comme ça devrait marcher:

List<File> fileCollection = new ArrayList<File>(files.values());

Collections.sort(fileCollection, 
                 new Comparator<File>() 
                 {
                     public int compare(File fileA, File fileB) 
                     {
                         final int retVal;

                         if(fileA.fileID > fileB.fileID)
                         {
                             retVal = 1;
                         }
                         else if(fileA.fileID < fileB.fileID)
                         {
                             retVal = -1;
                         }
                         else
                         {
                             retVal = 0;
                         }

                         return (retVal);                         
                     }
                 });

Answer 2

Malheureusement, il est impossible d'extraire les données d'un HashMap dans un ordre reconnaissable. Vous devez soit placer toutes les valeurs dans un TreeSet avec un comparateur qui utilise l'identifiant de fichier, soit les placer dans un ArrayList et les trier avec Collections.sort, à nouveau avec un comparateur qui compare comme vous le souhaitez.

La méthode TreeSet ne fonctionne pas s'il y a des doublons, et c'est peut-être excessif, car vous n'allez pas ajouter ou supprimer des éléments de l'ensemble. La méthode Collections.sort est une bonne solution pour les instances de ce type, dans lesquelles vous allez récupérer l'ensemble du hachage, trier les résultats, puis jeter la collection triée dès que vous avez généré le résultat.

Answer 3

OK, c'est ce que j'ai proposé. Semble résoudre le problème, retourne une chaîne avec les objets File bien ordonnés par leur fileId.

public String getFiles()
{   
    List<File> fileList = new ArrayList<File>(files.values());

    Collections.sort(fileList, new Comparator<File>()
                               {
                                   public int compare(File fileA, File fileB)
                                   {
                                       if(fileA.getFileId() > fileB.getFileId()) 
                                       {
                                           return 1;
                                       }
                                       else if(fileA.getFileId() < fileB.getFileId()) 
                                       {
                                           return -1;
                                       }
                                       return 0;
                                   }
                               });

    StringBuilder allFilesString = new StringBuilder();

    for(File file : fileList) {
        allFilesString.append(file.toString());
    }
    return allFilesString.toString();
}

Je n'ai jamais utilisé Comparator auparavant (relativement nouveau en Java). J'apprécierais donc tout commentaire en cas d'implémentation incorrecte.

Answer 4

Pourquoi ne pas le collecter dans un tableau, le trier, puis le concaténer?

- MarkusQ

Answer 5

Vous devrez ajouter votre collection Values() à une ArrayList et la trier à l'aide de Collections.sort() avec une instance de Comparator personnalisée avant de la parcourir.

BTW, notez qu'il est inutile d'initialiser le StringBuffer avec la taille de la collection, puisque vous ajouterez bien plus d'un caractère par élément de collection.

Answer 6

Créez une liste temporaire, puis ajoutez-y chaque paire de données. Triez-le avec Collections.sort () en fonction de votre comparateur personnalisé, puis vous obtiendrez la liste dans l'ordre de votre choix.

Voici la méthode que vous recherchez: http://java.sun.com/javase/6/docs/api/java/util/Collections.html#sort (java.util.List ,% 20java.util.Comparator)

Answer 7

J'ai créé LinkedHashMap une douzaine de fois avant de l'ajouter à l'ensemble des collections.

Vous souhaitez probablement créer une collection TreeHashMap.

La création d'une deuxième collection et l'ajout de tout élément ajouté aux deux ne sont pas vraiment une question de taille, et vous obtenez les performances des deux (avec le coût d'un peu de temps lorsque vous ajoutez).

Faites-le comme une nouvelle collection pour que votre code reste propre et net. La classe de collection ne devrait comporter que quelques lignes et remplacer simplement votre hashmap existant ...

Si vous prenez l'habitude de toujours emballer vos collections, tout cela fonctionne, vous n'y pensez même jamais.

Answer 8

StringBuffer allFilesString = new StringBuffer(fileCollection.size());

À moins que tout votre file.toString () ne compte qu'un caractère en moyenne, vous réduisez probablement le StringBuffer trop petit. (Si ce n’est pas correct, vous pouvez aussi bien ne pas le définir et simplifier le code). Vous obtiendrez de meilleurs résultats si vous lui donnez un multiple de la taille. De plus, StringBuffer est synchronisé, mais StringBuilder ne l’est pas et est plus efficace ici.

Answer 9

Supprimer les if déclarations inutiles.

List<File> fileCollection = new ArrayList<File>(files.values());
Collections.sort(fileCollection, 
             new Comparator<File>() {
                 public int compare(File a, File b) {
                     return (a.fileID - b.fileID);
                 }
             });