Trier ArrayList via une valeur spécifique dans l'objet ArrayList?

Question

J'ai un système de score que je veux créer, dans lequel il y a une liste de joueurs allant du plus haut au plus bas.

Mon PlayerObject.class Classe:

public class PlayerObject { 

    private String playerName; 
    private int playerScore; 

    public int getScore() { 
     return this.playerScore; 
    } 

    public String getName() { 
     return this.playerName; 
    } 

    public void setNameAndScore(String givenName, int givenScore) { 
     this.playerName = givenName; 
     this.playerScore = givenScore; 
    } 

} 

Mon tableau:

ArrayList<PlayerObject> allPlayers = new ArrayList<PlayerObject>(); 

Toute idée comment je peux trier chaque joueur dans la liste de tableau en fonction de leur playerScore attribut ?

Merci!

Answer 1

Il y a plusieurs façons de le faire. Tout d'abord c'est classe PlayerObject:

public class PlayerObject implements Comparable<PlayerObject> { 
    private String playerName; 
    private int playerScore; 

    public PlayerObject(String playerName, int playerScore) { 
     this.playerName = playerName; 
     this.playerScore = playerScore; 
    } 

    public String getPlayerName() { 
     return playerName; 
    } 

    public int getPlayerScore() { 
     return playerScore; 
    } 

    @Override 
    public int compareTo(PlayerObject o) { 
     return Integer.compare(playerScore, o.playerScore); 
    } 
} 

Et voici comment vous pouvez faire le tri:

public class Main { 
    public static void main(String[] args) { 
     System.out.println("Hello World!"); 

     List<PlayerObject> players = new ArrayList<>(2); 
     players.add(new PlayerObject("player1", 2)); 
     players.add(new PlayerObject("player2", 4)); 

     // if PlayerObject implements Comparable<PlayerObject> 
     Collections.sort(players); 
     // or if you want explicit Comparator 
     players.sort(new Comparator<PlayerObject>() { 
      @Override 
      public int compare(PlayerObject o1, PlayerObject o2) { 
       return Integer.compare(o1.getPlayerScore(), o2.getPlayerScore()); 
      } 
     }); 
     // or you can use lambda if you use Java 8 
     players.sort((o1, o2) -> Integer.compare(o1.getPlayerScore(), o2.getPlayerScore())); 
     // or even more concise 
     players.sort(Comparator.comparingInt(PlayerObject::getPlayerScore)); 
    } 
} 

Voici une documentation qui vous aidera:

Comparable

Comparator

Answer 2

Envisagez d'utiliser un comparateur.

classique un

Collections.sort(allPlayers, new Comparator<PlayerObject>() { 
    @Override 
    public int compare(PlayerObject p1, PlayerObject p2) { 
     return p1.getScore().compareTo(p2.getScore()); 
    } 
}); 

Et avec java-8 support Lambda

allPlayers.sort(
     (PlayerObject p1, PlayerObject p2) -> p1.getScore().compareTo(h2.getScore())); 

Answer 3

L'un des moyens possibles pour mettre en œuvre Comparable dans votre classe PlayerObject et remplacer la méthode compareTo.

public class PlayerObject implements Comparable<PlayerObject> { 

    ... 
    ... 
    @Override 
    public int compareTo(PlayerObject o) { 
    // You can interchange the return value (-1 and 1) to change the sorting order 

     if(getPlayerScore() > o.getPlayerScore()) 
     { 
      return -1 
     } 
     else if(getPlayerScore() < o.getPlayerScore()) 
     { 
      return 1; 
     } 
     return 0; 
    } 
} 

Answer 4

Avec java 8, vous pouvez le faire de cette façon, sans mettre en œuvre toute interface:

allPlayers = allPlayers.stream() 
    .sorted(Comparator.comparingInt(PlayerObject::getScore)) 
    .collect(Collectors.toList()); 

Ou tout simplement:

Collections.sort(allPlayers, Comparator.comparingInt(PlayerObject::getScore))