Improving quality of my code

Helper is not a good class name. You should be able to come up with something that provides more context to what the functions are doing.

In getPlayers(), I would loop and add instead of adding all and then removing.

private static List<User> getPlayers(List<User> users) {
    List<User> filteredUsers = new ArrayList<User>();
    for (User user : users) {
        if (user.isPlayer()) {
            filteredUsers.add(user);
        }
    }
    return filteredUsers;
}

I also added curly braces around the if block. It's not necessary, but it will prevent errors if you need to add an extra line later. You also included them in createPlayersScoreMap(), so it's best to be consistent.

If you have a large number of players and scores, you can make createPlayersScoreMap() more efficient (in terms of Big O processing). If n is the number of users and m is the number of scores, the method is currently O(n*m). However, if you sum all the scores first and then filter the players, you can get O(n+m).

public static Map<User, BigDecimal> createPlayerScores(List<User> users, List<Score> scores) {
    List<User> players = getPlayers(users);
    Map<User, BigDecimal> playerScores = new HashMap<User, BigDecimal>();

    for (Score score: scores) {
        User player = score.getPlayer();
        BigDecimal sumScore = score.getResult();
        if (playerScores.containsKey(player) {
            sumScore = sumScore.add(playerScores.get(player));
        }
        playerScores.put(player, sumScore);
    }
    Map<User, BigDecimal> filteredScores = new HashMap<User, BigDecimal>();
    for (User player : players) {
        filteredScores.put(player, playerScores.get(player));
    }
    return filteredScores;
}

I also change the name of the function/variable. They type system makes it obvious that you are dealing with a Map, you don't need to include it in the variable name. If the calling method has Lists and Maps that deal with players and scores, then it might be acceptable to include the type as part of the variable name.

The Helper is an absolutely ridicoulus class name. How about PlayerScoreMap? This might be a good idea because createPlayerScoreMap is actually a constructor! (As evidenced by the name).

The whole getPlayers helper is unneccessary, and backwards: All this does is to delete those users from a copied list that are not players, so that they are not iterated in the constructor. I have a better idea: Simply skip over those users that you don't like, e.g.

for (User user : users) {
  if (!user.isPlayer()) continue;

  ... // score summation
}

Why are you using BigDecimals? This is only reasonable when you have a scoring system that actually uses arbitrary fractional values (which is quite unusual). Most systems use integer scores or fixed point values, which can easily be translated to integers. Even if scores can be arbitrary values, an insignificant loss of precision may be acceptable. But this relies on the number of scores and the problem space, which I do not know about.