Max value from list of list in Java

I'm trying to get the highest value by applying a filter

I have an object that contains a team object and a list of cards.
so I need to get the highest value from the card list in the card weight attribute, where the team is A, and return the player.

public class Player {
  private String name;
  private List<Card> cards;
  private Team team;
  // getters and setters
}

public class Team {
  private int id;
  private int points;
  // getters and setters
}

public class Card {
  private int weightCard;
  // getters and setters
}

the code that I was trying to execute

int maxPointsTeamA = players
	.stream()
	.filter( x -> x.getTeam().equals(teamA))
	.map(n -> n.getCards()
	.stream()
	.map( c -> c.getWeigthCard()).max(Comparator.naturalOrder()));

players is a list of players (4 players)

error:

Type mismatch: cannot convert from Stream<Object> to int

help me please, it's for academic work

Replace both of your map calls to mapToInt, for starters. You then do not need the Comparator.naturalOrder().

Secondly, your first map call contains this lambda:

n -> n.getCards().stream().map(c -> c.getWeightCard()).

That turns a single 'n', whatever that might be, into a stream of whatever weightcard returns (which is not code you pasted). The point of map is to turn one thing into one other thing, not a stream of things. You can use flatmap for that instead, so presumably, first flatMap to a stream of cards, then map that to an int via the weightcard function, and then you can max.

Putting it all together:

int maxPointsTeamA = players
            .stream()
            .filter(x -> x.getTeam().equals(teamA))
            .flatMap(n -> n.getCards().stream())
            .mapToInt(c -> c.getWeightCard())
            .max()
            .orElse(0);

EDIT: Ah, yes, I forgot max() returns an OptionalInt; fixed.

This should work

int maxPointsTeamA= players
        .stream()
        .filter( x -> x.getTeam().equals(teamA))
        .flatMap(player -> player.getCards()
                .stream()
                .map(card -> card.getWeightCard()))
        .max(Comparator.naturalOrder())
        .orElse(0);

Try this.

• convert the list to a stream.
• filter for the correct team
• Then create a stream of the weights and select the max

            int maxCardWeightPlayerTeamA = players
	               .stream()
	               .filter( x -> x.getTeam().equals(teamA))
	               .flatMap(n -> n.getCards()
	               .stream().map(c -> c.getWeightCard()))
                    .max(Comparator.naturalOrder())
	               .orElse(-1);

This has been tested with similar classes and operates correctly.

Answering based on the expectation

> so I need to get the highest value from the card list in the card
> weight attribute, where the team is A, and return the player.

While looking for a player to be returned, you should not map the Stream, rather find the max using the custom Comparator as

Optional<Player> maxCardWeightPlayer = players
        .stream()
        .filter(x -> x.getTeam().equals(teamA)) // filter players by team
        .max(Comparator.comparing(player -> player.getCards().stream()
                .map(Card::getWeightCard)
                .max(Comparator.naturalOrder()) // maximum card weight
                .orElse(0))); // find max player by maximum card weight

Others have already given good answers. But, here is an answer which also generates test data for you (by using streams) and lets you get the max.

Override/define the toString() method for Team:

class Team {
private int id;
private int points;
@Override
public boolean equals(Object otherTeam){
Team t = (Team) otherTeam;
return this.getId() == t.getId() ? true : false;
}
}

Solution :
I have added comments in the code to explain how the solution works.

class Test{
//MAIN METHOD - START HERE !!!
public static void main(String [] args){
//Prepare test data.
List<Player> players = getTestData();
Player onePlayer = players.get(players.size()/2);//3rd player when list has 5 players.
List<Card> onePlayerCards = onePlayer.getCards();
Team teamA = new Team(onePlayer.getTeam().getId(), onePlayer.getTeam().getPoints());
//Test the max finder.
Integer max = getMax(players, teamA);
System.out.println("Expected max: " + onePlayerCards.get(onePlayerCards.size()-1).getWeightCard());
System.out.println("Actual max: " + max);
}
public static int getMax(List<Player> players, Team team){
//Replace this with method with any other method you'd like to test.
return getMax_byMasterJoe2(players, team);
}
public static int getMax_byMasterJoe2(List<Player> players, Team team){
Integer max = players
.stream()
//Extract player whose team is teamA.
.filter(player -> player.getTeam().equals(team))
//Get the cards of a player.
//.map() gives us Stream<List<Card>>. flatMap() gives us Stream<Card> which is what we need.
.flatMap(player -> player.getCards().stream())
//Get only the weights of each card of a player.
.mapToInt(Card::getWeightCard)
//Get maximum weight of a player's cards.
.max()
//If player has zero cards, then return 0.
.orElse(0);
return max;
}
public static List<Player> getTestData(){
List<Player> players = Stream
//Players numbers.
.of(1,2,3,4,5)
//Use player number to make player object.
.map(n -> new Player(
//Player name.
"player" + n,
//Generate n cards for n-th player. Ex. n=3 gives cards with weights 10, 20, 30.
IntStream.range(1, n+1).mapToObj(num -> new Card(num * 10)).collect(Collectors.toList()),
//Team.
new Team(n, n * 10)))
.collect(Collectors.toList());
//Remove all cards of last player for testing.
players.get(players.size()-1).getCards().clear();
return players;
}
}