En comparant les valeurs Longues à l'aide de Collections.de tri(objet)

Je suis en train de trier une simple liste d'objets par un long - le ci-dessous ne fonctionne pas parce que l'une des cordes longues est poussée vers le haut tout simplement parce qu'il commence avec un nombre inférieur. Donc, je suis à la recherche d'un moyen de résoudre ces par le réel à long valeurs directement

L'actuel obj mise en œuvre ressemble à quelque chose comme ci-dessous. Dans la classe, je suis en utilisant ce que j'appel des Collections.de tri(arbres);

public class Tree implements Comparable<Tree> {
    public String dist; //value is actually Long

    public int compareTo(Tree o) {
        return this.dist.compareTo(o.dist);
    }
}

Pourquoi ne pas simplement comparer les valeurs long de dist dans votre compareTo(Arbre o) méthode?
Les chaînes sont comparées par ordre alphabétique (pas vraiment, mais c'est une bonne façon de penser). Par conséquent, les 12 > 111. Si vous avez besoin de comparer des nombres d'utiliser des chiffres, c'est à dire ajouter un champ plus long. Ou, dans le pire des cas, de comparer le résultat de la Longue.parseLong(dist)
En fait, j'ai fait la comparaison d'un double tout le temps - désolé les gars (je suis allé avec le Double.comparer comme ma solution réelle) a décerné ce que je ressentais était une grande réponse à la Longue problème - drapeau pour la suppression si rien d'autre
L'Utilisation 'De Long.comparer(long x, long y)', voir la réponse ci-dessous

OriginalL'auteur Toran Billups | 2011-05-30

pourquoi ne pas enregistrer un long là:

public class Tree implements Comparable<Tree> {
    public long dist; //value is actually Long

    public int compareTo(Tree o) {
        return this.dist<o.dist?-1:
               this.dist>o.dist?1:0;
    }
}

que le ou la première à comparer la longueur des chaînes et de les comparer

public String dist; //value is actually Long
public int compareTo(Tree o) {
    if(this.dist.length()!=o.dist.length())
          return this.dist.length()<o.dist.length()?-1:1;//assume the shorter string is a smaller value
    else return this.dist.compareTo(o.dist);
}

Mise à jour: Depuis Java 7, vous pouvez faire Long.compare(x, y); au lieu d'écrire un tel code vous-même (pas une révolution, mais en plus simple).
Dans android, @ChristopheRoussy la solution ne fonctionne que pour les API de 19 ans et au-dessus.

OriginalL'auteur ratchet freak

27

Si vous avez un objet que vous souhaitez trier sur une valeur de type long, et qu'il implémente Comparable, dans Java 7+ vous pouvez utiliser Long.compare(long x, long y) (qui renvoie un int)

E. g.
```
public class MyObject implements Comparable<MyObject>
{
  public long id;

  @Override
  public int compareTo(MyObject obj) {
    return Long.compare(this.id, obj.id);
  }
}
```
Appel Collections.sort(my_objects) où my_objects est quelque chose comme
```
  List<MyObject> my_objects = new ArrayList<MyObject>();
  //+ some code to populate your list
```
cette option est uniquement disponible à partir de l'API de niveau 19

OriginalL'auteur area5one
14

eh bien, si dist variable est en fait longtemps, alors vous pouvez essayer en utilisant
```
public int compareTo(Tree o) {
    return Long.valueOf(this.dist).compareTo(Long.valueOf(o.dist));
}
```
ne compile pas (Longtemps.parseLong retour primitive de long)
s/parseLong/valueOf/

OriginalL'auteur cipher
3

Cela dépend de comment vous voulez faire les choses? Voulez-vous garder au courant de la mise en œuvre de Comparable? Si oui, utiliser la méthode de tri qui prend un Comparateur et de mettre en œuvre une coutume de comparaison qui utilise la "longue" les valeurs de la chaîne (Long.parseLong(dist)). Si non, puis il suffit de modifier le compareTo et l'utilisation à Long valeurs de la "dist".

BTW, j'aimerais revoir la logique et de me demander pourquoi "dist" est de type String, quand il est en fait une Longue?

OriginalL'auteur Sanjay T. Sharma

Juste un exemple que j'ai fait pour trier les Fichiers par date en utilisant un Long comparateur:

public File[] getAllFoldersByDescendingDate(File folder) {
    if (!folder.isDirectory()) {
        return null;
    }
    allFiles = folder.listFiles();
    Arrays.sort(allFiles, new Comparator<File>()
    {
        public int compare(final File o1, final File o2)
        {
            return Long.compare(o2.lastModified(), o1.lastModified());
        }
    });
    return allFiles;
}

OriginalL'auteur djangofan

Pourquoi ne pas

public class Tree implements Comparable<Tree> {
    public Long dist;

    public int compareTo(Tree o) {
        return this.dist.compareTo(o.dist);
    }
}

OriginalL'auteur astay13

Vous devez vous connecter pour publier un commentaire.