Je ne sais pas pourquoi ma liste n'est pas triée.

J'utilise Collection.sort, il semble faire le travail, mais lorsque je lance UnitTest, il génère une erreur.

Attendu: characterWithMaxVotes [voteCount: 100]

Réel: characterMiddle75 [voteCount: 75]

//Exact same method as in the Character class (pasted for better readability on SO question)
public static void sortCharactersByVotes(List<Character> lstCharacters) {
    Collections.sort(lstCharacters, new Comparator<Character>() {
        @Override
        public int compare(Character character, Character p1) {
            int result = (character.getVoteCount() > p1.getVoteCount()) ? 1 : 0;
            return result;
        }
    });
}

@Test
public void sortCharactersByVoteCounts() {
    Character characterWithMinVotes = Character.newBuilder().name("characterWithMinVotes").voteCount(0).build();
    Character characterMiddle25 = Character.newBuilder().name("characterMiddle25").voteCount(25).build();
    Character characterMiddle75 = Character.newBuilder().name("characterMiddle75").voteCount(75).build();
    Character characterWithMaxVotes = Character.newBuilder().name("characterWithMaxVotes").voteCount(100).build();

    List<Character> lstCharacters = new ArrayList<>();
    
    lstCharacters.add(characterMiddle75);
    lstCharacters.add(characterWithMaxVotes );
    lstCharacters.add(characterMiddle25);
    lstCharacters.add(characterWithMinVotes);

    sortCharactersByVotes(lstCharacters);

    System.out.print(lstCharacters);
    
    assertEquals(lstCharacters.get(0), characterWithMaxVotes);
    assertEquals(lstCharacters.get(1), characterMiddle75);
    assertEquals(lstCharacters.get(2), characterMiddle25);
    assertEquals(lstCharacters.get(3), characterWithMinVotes);
}

Comment le faire correctement, merci pour votre aide.

PS: comme demandé, voici ma classe de personnage

Public class Character {

private static final String TAG = "Character";

private int id;
private String name = "";
public int voteCount;
public boolean isVotedByUser = false;

public int getId() {
    return id;
}
public int getVoteCount() {
    return voteCount;
}
public String getName() {
    return name;
}

public static CharacterBuilder newBuilder(){
    return new CharacterBuilder();
}

@Override
public String toString() {
    return name + "[voteCount : " + voteCount + "]";
}

public static void sortCharactersByVotes(List<Character> lstCharacters) {
    Collections.sort(lstCharacters, new Comparator<Character>() {
        @Override
        public int compare(Character character, Character p1) {
            int result = (character.getVoteCount() > p1.getVoteCount()) ? 1 : 0;
            return result;
        }
    });
}

public static class CharacterBuilder {

    public Character character;

    CharacterBuilder() {
        character = new Character();
    }

    public CharacterBuilder id(int id) {
        character.id = id;
        return this;
    }

    public CharacterBuilder name(String name) {
        character.name = name;
        return this;
    }

    public CharacterBuilder voteCount(int voteCount) {
        character.voteCount = voteCount;
        return this;
    }

    public Character build() {
        return character;
    }

}

}

2
Fundhor 25 janv. 2017 à 22:46

3 réponses

Votre sorte de méthode de comparaison doit être modifiée pour

public static void sortCharactersByVotes(List<Character> lstCharacters) {
    lstCharacters.sort(Comparator.comparingInt(Character::getVoteCount));
}

Remarque - La comparaison est basée sur l'entier getVoteCount de Character et ceci est pris en charge dans Java 8+ .

0
Naman 25 janv. 2017 à 20:01

La mise en œuvre de votre Comparator n'est pas correcte, car vous voulez d'abord avoir la valeur la plus élevée (et non la valeur la plus basse opposée en premier), vous êtes censé renvoyer une valeur positive si character.getVoteCount() < p1.getVoteCount() et une valeur négative si character.getVoteCount() > p1.getVoteCount(), vous devez utiliser Integer.compare(int x, int y) pour comparer les valeurs de getVoteCount() (en supposant qu'il renvoie un int) tel que votre Comparator pourrait être:

new Comparator<Character>() {
    @Override
    public int compare(Character c1, Character c2) {
        return Integer.compare(c2.getVoteCount(), c1.getVoteCount());
    }
}

NB: Ne comparez pas les valeurs de getVoteCount() avec une simple soustraction, sinon vous prendrez le risque d'obtenir des résultats incorrects car elle est sujette à des problèmes de débordement.

3
Nicolas Filotto 25 janv. 2017 à 20:11

Je pense qu'il vaut mieux changer un peu le comparateur mis en place. Essayer:

public static void sortCharactersByVotes(List<Character> lstCharacters) {
    Collections.sort(lstCharacters, new Comparator<Character>() {
        @Override
        public int compare(Character character, Character p1) {
            int result = (character.getVoteCount() - p1.getVoteCount());
            return result;
        }
    });
}

Une autre chose est que vous ajoutez deux fois le

characterWithMaxVotes

J'espère que cela aide!

1
melli-182 25 janv. 2017 à 19:58