Java 8: Stream API – Parte 2, conhecendo a API

17_1

Após falar sobre a motivação para usar o Stream API, o foco desse artigo será mostrar uma visão geral da API. Para exemplificar, será utilizado o mesmo modelo do artigo anterior, um time de futebol.

public class Team {
private List players;
//…
}

public class Player {

private String name;

private int gols;

private Position position;

//...
}

public enum Position {
GOALKEEPER,DEFENDER, FORWARDS
}

Mapeamento

É possível realizar o mapeamento e retornar apenas um campo desejável, por exemplo, retornar a listas de nomes dos jogadores.

public List getNames() {
return players.stream().map(Player::getName).
collect(Collectors.toList());
}

Collector vs Collectors

A interface Collector que realiza uma operação de redução mutável colocando os resultados em uma representação e a classe Collectors tem várias implementações úteis da interface.

Retornando Set
public List getPlayers() {
return players.stream().collect(Collectors.toList());
}
Retornando List
public Set getPlayers() {
return players.stream().collect(Collectors.toSet());
}
Criando o seu próprio retorno
public Queue getPlayers() {
return players.stream().collect(Collectors.toCollection(LinkedList::new));
}

Ordenação

É possível ordenar de forma natural, implementando o Comparable. Para exemplificar isso, a classe Player será modificado comparando os jogadores pelo nome.

public class Player implements Comparable {
@Override
public int compareTo(Player player) {
return name.compareTo(player.name);
}
}

Assim é possível ordenar pelo nome:

public List getPlayers() {
return players.stream().sorted()
.collect(Collectors.toList());
}

Ou:

public List getPlayers() {
return players.stream().sorted(Comparator.naturalOrder())
.collect(Collectors.toList());
}

Também é possível definir uma ordenação, para isso, basta usar o método comparing dentro do Comparator.

public List getPlayers() {
return players.stream().sorted(Comparator
.comparing(Player::getGols))
.collect(Collectors.toList());
}

Foma descendente.

public List getPlayers() {
return players.stream().sorted(Comparator
.comparing(Player::getGols).reversed())
.collect(Collectors.toList());
}

Juntar ordenações:

public List getPlayers() {
return players.stream().sorted(Comparator.comparing(Player::getName)
.thenComparing(Comparator.comparing(Player::getGols)))
.collect(Collectors.toList());
}

Filtragem.

Já discutido no primeiro post, vale adicionar que é possível, assim como as ordenações, realizar mais de uma condição. É possível combinar utilizando os operadores or ou and, além de negar o predicate usando o negate. Para o exemplo, serão listados todos os atacantes que fizeram mais de 3 gols.

public List getGoodFowarder() {
Predicate isFowarder = Player::isFowarder;
Predicate hasMoreThanThreeGolds = p -> p.getGols() >3;
return players.stream().filter(isFowarder.and(hasMoreThanThreeGolds)).collect(Collectors.toList());
}

public List getNotFowarder() {
Predicate isFowarder = Player::isFowarder;
return players.stream().filter(isFowarder.negate()).collect(Collectors.toList());
}

Caso se queria limitar o número de elementos na lista, pular elementos e também retornar o primeiro ou algum resultado existe os métodos limit, skip, findFirst e findAny respectivamente.

public List getThreeGoodFowarder() {
Predicate isFowarder = Player::isFowarder;
Predicate hasMoreThanThreeGolds = p -> p.getGols() >3;
return players.stream().filter(isFowarder.and(hasMoreThanThreeGolds)).limit(3).collect(Collectors.toList());
}

public Player getSecondGoodFowarder() {
Predicate isFowarder = Player::isFowarder;
Predicate hasMoreThanThreeGolds = p -> p.getGols() >3;
return players.stream().filter(isFowarder.and(hasMoreThanThreeGolds)).skip(1).findFirst().get();
}

public Player getAGoodFowarder() {
Predicate isFowarder = Player::isFowarder;
Predicate hasMoreThanThreeGolds = p -> p.getGols() >3;
return players.stream().filter(isFowarder.and(hasMoreThanThreeGolds)).findAny().get();
}

public List getFowarderOrDefenter() {
Predicate isFowarder = Player::isFowarder;
Predicate isDefener = Player::isDefender;
return players.stream().filter(isFowarder.or(isDefener)).limit(3).collect(Collectors.toList());
}

 

Anúncios

Um comentário sobre “Java 8: Stream API – Parte 2, conhecendo a API

Deixe um comentário

Preencha os seus dados abaixo ou clique em um ícone para log in:

Logotipo do WordPress.com

Você está comentando utilizando sua conta WordPress.com. Sair / Alterar )

Imagem do Twitter

Você está comentando utilizando sua conta Twitter. Sair / Alterar )

Foto do Facebook

Você está comentando utilizando sua conta Facebook. Sair / Alterar )

Foto do Google+

Você está comentando utilizando sua conta Google+. Sair / Alterar )

Conectando a %s