如何链接 java 中的两个列表？

Question

I am trying to create a kind of highscore system in a program. I have a list of scores and then a list of names. I want to add the scores and names to the end of the ArrayList and then sort the list of scores using collections. The problem is that I need to sort the list of names in the exact same way.

Start [1, 3, 2] ["name 1", "name 2", "name 3"]

Sorted [3, 2, 1] ["name 2", "name 3", "name 1"]

Like that.

Answer 1

You could map each of the names to a rank as an int, then sort the map by value

import Java.util.HashMap;

HashMap<String, Integer> scoresMap = new HashMap<String, Integer>();

//add a value into a map like this
scoresMap.put("name 1", 3);

//then make a function to sort the map
HashMap<String, Integer> sortedScoresMap;
sortedScoresMap = sortMapByValue(scoresMap);

Answer 2

You should probably use Map - Map javadoc .

I would use username as key and you can input score as value .

Map<String, Integer> scores = new HashMap<>();

to insert new score, use:

if (!score.keySet().contains("username")) score.put("username", 10);

to iterate and update:

if (score.keySet().contains("username")) score.replace("username", newScore);

Answer 3

You can try storing a list of object which will contains both names and scores instead of storing those in separate lists. Then you can pass your comparator to sort the list using the score.

Answer 4

Why not create an "playerScore" object, that handles name and score, and put this object inside the array, and using the "getScore()" method on sorting? This way, you will allways have just one list, and one object to handle with it. If you use map to put the names and use score as value in the map, you will have a problem with two players with same score, as example, be carefl about this.

Answer 5

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;

public class so65891032 {
    public static void main(String[] args) {
        List<ScoreDetails> scores = new ArrayList<>();
        //Add scores using add()

        var sortedScores = scores.stream()
                .sorted()//Uses comparable, use this one or one below
                .sorted(ScoreDetails.SCORE_COMPARATOR)//Uses Comparator
                .collect(Collectors.toList());
    }
}

class ScoreDetails implements Comparable<ScoreDetails> {
    public static final Comparator<ScoreDetails> SCORE_COMPARATOR = new Comparator<ScoreDetails>() {
        @Override
        public int compare(ScoreDetails o1, ScoreDetails o2) {
            return o1.score - o2.score;
        }
    };

    public String name;
    public int score;

    @Override
    public String toString() {
        return name + " " + score; //Will print out in the format you are looking for
    }

    @Override
    public int compareTo(ScoreDetails other) {
        return score - other.score;
    }
}

Using streams you can do sorting. The sorted method can take a comparitor which can be defined anonymously or you can store as a constant if you plan to use it repeatedly. Here I made it simple and just implements Comparable instead on the ScoreDetail class.

Another point, if you want to always ensure it's sorted by score you may want to consider a data structure that suits your needs better than a List or [] (arrays). My assumption here is that you only need to sort it at a specific point otherwise you are maintaining some order. We don't have enough information to determine that in the problem.

In order to print out the strings in the format that you requested. I have overrode the toString() method for ScoreDetails so many common output functions will display what you are looking for.

Answer 6

I would store your scoreboard in Map, where key is name and value is score instead of two Lists.

Then this map sort by value

Map<String, Integer> scoreboard = new HashMap<>();
scoreboard.put("name 1", 1);
scoreboard.put("name 2", 3);
scoreboard.put("name 3", 2);

LinkedHashMap<String, Integer> sortedScoreboard = scoreboard.entrySet()
    .stream()
    .sorted(Map.Entry.<String, Integer> comparingByValue().reversed())
    .collect(Collectors.toMap(
        Map.Entry::getKey,
        Map.Entry::getValue, 
        (e1, e2) -> e1, LinkedHashMap::new));

Result:

{name 2=3, name 3=2, name 1=1}