Java 是否通过ArrayList对象中的特定值对ArrayList排序？

我有一个我想要创建的评分系统，其中有一个从最高到最低的球员名单

我的PlayerObject.class:

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;
    }

}

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

我的阵列：

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;
    }

}

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

ArrayList allPlayers=new ArrayList（）；

---

知道如何根据玩家的核心属性对阵列列表中的每个玩家进行排序吗？

有很多方法可以做到这一点。首先，这是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);
    }
}

公共类PlayerObject实现可比较{
私人弦乐演奏者姓名；
私人int playerScore；
公共PlayerObject（字符串playerName，int playerCore）{
this.playerName=playerName；
this.playerScore=playerScore；
}
公共字符串getPlayerName（）{
返回playerName；
}
public int getPlayerScore（）{
返回playerScore；
}
@凌驾
公共int比较（PlayerObject o）{
返回整数。比较（playerScore，o.playerScore）；
}
}

这就是如何对其进行排序：

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));
    }
}

公共类主{
公共静态void main（字符串[]args）{
System.out.println（“你好，世界！”）；
球员名单=新的ArrayList（2）；
添加（新的PlayerObject（“player1”，2））；
添加（新的PlayerObject（“player2”，4））；
//如果PlayerObject实现了可比较
集合。排序（玩家）；
//或者，如果您想要显式比较器
players.sort（新的Comparator（）{
@凌驾
公共整数比较（PlayerObject o1，PlayerObject o2）{
返回整数.compare（o1.getPlayerScore（），o2.getPlayerScore（））；
}
});
//如果使用Java8，也可以使用lambda
排序（（o1，o2）->Integer.compare（o1.getPlayerScore（），o2.getPlayerScore（））；
//或者更简洁
排序（Comparator.comparingit（PlayerObject:：getPlayerScore））；
}
}

以下是有助于您的文档：

---

有很多方法可以做到这一点。首先，这是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);
    }
}

公共类PlayerObject实现可比较{
私人弦乐演奏者姓名；
私人int playerScore；
公共PlayerObject（字符串playerName，int playerCore）{
this.playerName=playerName；
this.playerScore=playerScore；
}
公共字符串getPlayerName（）{
返回playerName；
}
public int getPlayerScore（）{
返回playerScore；
}
@凌驾
公共int比较（PlayerObject o）{
返回整数。比较（playerScore，o.playerScore）；
}
}

这就是如何对其进行排序：

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));
    }
}

公共类主{
公共静态void main（字符串[]args）{
System.out.println（“你好，世界！”）；
球员名单=新的ArrayList（2）；
添加（新的PlayerObject（“player1”，2））；
添加（新的PlayerObject（“player2”，4））；
//如果PlayerObject实现了可比较
集合。排序（玩家）；
//或者，如果您想要显式比较器
players.sort（新的Comparator（）{
@凌驾
公共整数比较（PlayerObject o1，PlayerObject o2）{
返回整数.compare（o1.getPlayerScore（），o2.getPlayerScore（））；
}
});
//如果使用Java8，也可以使用lambda
排序（（o1，o2）->Integer.compare（o1.getPlayerScore（），o2.getPlayerScore（））；
//或者更简洁
排序（Comparator.comparingit（PlayerObject:：getPlayerScore））；
}
}

以下是有助于您的文档：

---

考虑使用比较器

经典的

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

---

考虑使用比较器

经典的

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

---

在

PlayerObject

类中实现

compariable

并重写

comparieto

方法的一种可能方法

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;
    }
}

公共类PlayerObject实现可比较{
...
...
@凌驾
公共int比较（PlayerObject o）{
//您可以交换返回值（-1和1）来更改排序顺序
如果（getPlayerScore（）>o.getPlayerScore（））
{
返回-1
}
else if（getPlayerScore（）

在

PlayerObject

类中实现

compariable

并重写

comparieto

方法的一种可能方法

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;
    }
}

公共类PlayerObject实现可比较{
...
...
@凌驾
公共int比较（PlayerObject o）{
//您可以交换返回值（-1和1）来更改排序顺序
如果（getPlayerScore（）>o.getPlayerScore（））
{
返回-1
}
else if（getPlayerScore（）

使用java 8，您可以这样做，而无需实现任何接口：

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

或者只是：

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

---

使用java 8，您可以这样做，而无需实现任何接口：

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

或者只是：

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

可能的重复可能的重复