Java, comment utiliser compareTo pour trier une liste de tableaux

Im essayant de comprendre comment trier une liste de tableaux à l'aide de comparable, mon code ressemble à ceci:

 public class playerComparsion{

        public static void main(String[] args){ 


    ArrayList<Object> list = new ArrayList<Object>();      

        Player p1 = new Players(1,92,Zlatan);
    Player p2 = new Players(2,92,Hazard);
    Player p3 = new Players(1,82,Klose);

    list.add(p1);
    list.add(p2);
    list.add(p3);
        }
    } 
        class Players implements Comparable{

        int position;
             String name;
            int rating;

            public Players(int i, int j, String string)  {

                this.position=i;
                this.rating=j;
                this.name=string;
            }

             public void getRating() {
                    System.out.println(this.rating);
                    }
             public void getPos() {
                    System.out.println(this.position);
                    }
             public void getName() {
                    System.out.println(this.name);
                    }

            @Override
            public int compareTo(Object o) {
                //TODO Auto-generated method stub
                return 0;
            }

        }

Je veux trier la liste de tableaux basés sur l'attribut de notation. Je suppose que je devrais utiliser le compareTo fonction, mais je n'ai aucune idée de comment faire, quelqu'un peut-il m'aider?

compareTo compare les deux Joueurs et il est censé retourner un négatif, positif ou nul nombre en fonction de si il arrive avant, après ou à la même position.

OriginalL'auteur user3712130 | 2014-07-26

Au lieu de faire Player mettre en œuvre Comparable, vous obtenez plus de flexibilité par la mise en œuvre de Comparator<Player> classes. Par exemple:

class PlayerComparatorByRating implements Comparator<Player> {
    @Override
    public int compare(Player o1, Player o2) {
        return o1.getRating() - o2.getRating();
    }
}

class PlayerComparatorByName implements Comparator<Player> {
    @Override
    public int compare(Player o1, Player o2) {
        return o1.getName().compareTo(o2.getName());
    }
}

Après tout, Player a plusieurs champs, il est facile d'imaginer que, parfois, vous pourriez voulez commander des joueurs différemment. Un grand avantage de cette approche est la principe de responsabilité unique: un Player classe n'a qu'une seule chose, qui encapsule les données de joueur. Au lieu d'ajouter une plus grande responsabilité (tri), il est préférable de déplacer cette logique dans une autre classe.

Vous pouvez utiliser ces éléments de comparaison avec Collections.sort, par exemple:

Collections.sort(list, new PlayerComparatorByRating());
System.out.println(list);
Collections.sort(list, new PlayerComparatorByName());
System.out.println(list);

Conseils supplémentaires

Votre classe semble être nommé Players. Il est préférable de le renommer à Player.

La getName, getRating, getPos méthodes ne devraient pas retourner void et imprimer le résultat, mais en retour les valeurs de champ à la place.

Mieux utiliser des noms pour les arguments du constructeur, par exemple:

Player(int position, int rating, String name) {
    this.position = position;
    this.rating = rating;
    this.name = name;
}

Utiliser le bon type de liste pour stocker les joueurs:

List<Player> list = new ArrayList<Player>();

Veuillez formater votre code correctement. Les IDE peuvent le faire.

A suggéré la mise en œuvre

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
class Player {
private int position;
private int rating;
private final String name;
Player(int position, int rating, String name) {
this.position = position;
this.rating = rating;
this.name = name;
}
public int getRating() {
return rating;
}
public int getPos() {
return position;
}
public String getName() {
return name;
}
@Override
public String toString() {
return String.format("%s:%d:%d", name, position, rating);
}
}
class PlayerComparatorByRating implements Comparator<Player> {
@Override
public int compare(Player o1, Player o2) {
return o1.getRating() - o2.getRating();
}
}
class PlayerComparatorByName implements Comparator<Player> {
@Override
public int compare(Player o1, Player o2) {
return o1.getName().compareTo(o2.getName());
}
}
public class PlayerComparatorDemo {
public static void main(String[] args){
List<Player> list = new ArrayList<Player>();
Player p1 = new Player(1, 92, "Zlatan");
Player p2 = new Player(2, 92, "Hazard");
Player p3 = new Player(1, 82, "Klose");
list.add(p1);
list.add(p2);
list.add(p3);
Collections.sort(list, new PlayerComparatorByRating());
System.out.println(list);
Collections.sort(list, new PlayerComparatorByName());
System.out.println(list);
}
}

Un peu de navigation autour; devriez-vous faire un null vérifier dans votre comparer les méthodes??
Bonne question. Si vous autoriser les valeurs null dans vos collections, alors oui, vous devez ajouter la valeur null contrôles.
Nice, j'ai aimé ce que vous avez fait ici très infomative

OriginalL'auteur janos

5

Ne pas utiliser les raw d'un type avec Comparable. Au lieu de cela, utiliser Comparable<Players>. De cette façon, vous avez un accès direct à l'objet de soins sans avoir à lancer de Object.

L'échantillon compareTo serait celui-ci:
```
public int compareTo(Player other) {
return rating - other.getRating();
}
```
Alors, vous auriez fait...en quelque sorte, à l'aide de Collections.sort().
```
Collections.sort(list);
```
La raison pour Comparable<Players> est que Comparable lui-même est définie comme la prise d'un générique de type T.

Vous pouvez accéder à la cote directement, si vous le faites à partir de n'importe quelle méthode de Player, même pour un autre exemple, c'est à dire other.rating peut être utilisé à la place de other.getRating(). Il doit aussi être mentionné que la soustraction peut déborder et de produire une valeur illégale si les évaluations négatives sont autorisées.
Je ne comprends pas comment UTILISER la compareTo fonction. Je veux la liste de tableaux liste".
La chose est, il n'est pas vous qui est à l'aide de la compareTo fonction. Vous êtes seulement à honorer le contrat que vous avez besoin de mettre en place pour Collections.sort() pour fonctionner correctement. C'est en fait Collections.sort() qui rend l'utilisation de votre compareTo méthode, car elle seule sortes de choses qui sont Comparable. La façon dont vous l'appelez, il serait Collections.sort(list), mais je vais ajouter que dans la réponse.
Pourriez-vous nous expliquer un peu plus sur les raisons de l'écriture de return rating - other.getRating();? Je suis totalement confus au sujet de la compareto fonction.
Le lien dans la réponse ci-dessus vous emmène à la documentation de Comparable. Le principe de base est qu'il est de retour négatif, zéro ou un nombre positif pour inférieure, égale, ou supérieure. En soustrayant les deux champs qui nous intéresse, c'est le moyen le plus rapide à réaliser qu'à condition que les valeurs ne sont pas underflow.

OriginalL'auteur Makoto

De l'essayer.

public class Comparator_Test {
public static void main(String[] args) {
ArrayList<Players> list = new ArrayList<Players>();      
Players p1 = new Players(1,92,"Zlatan");
Players p2 = new Players(2,92,"Hazard");
Players p3 = new Players(1,82,"Klose");
list.add(p1);
list.add(p2);
list.add(p3);
PlayerComparator comparator = new PlayerComparator();
System.out.println(list);
Collections.sort(list, comparator);
System.out.println(list);
}
}
class Players {
int position;
String name;
int rating;
public Players(int i, int j, String string)  {
this.position=i;
this.rating=j;
this.name=string;
}
public void getRating() {
System.out.println(this.rating);
}
public void getPos() {
System.out.println(this.position);
}
public void getName() {
System.out.println(this.name);
}
public String toString() {
return rating + "";
}
}
class PlayerComparator implements Comparator<Players> {
@Override
public int compare(Players o1, Players o2) {
if(o1.rating > o2.rating) {
return 1;
}
if(o1.rating < o2.rating) {
return -1;
}
return 0;
}
}

OriginalL'auteur FruitDealer

Vous devez vous connecter pour publier un commentaire.