Comment utiliser les nouvelles fonctionnalités de Java9 Stream Collectors

Nouvelles fonctionnalités de Java 9 Stream Collectors

Java 8 introduit les collecteurs, qui sont utilisés pour accumuler des éléments d'entrée dans des conteneurs mutables tels que Map, List et Set. Cet article examine les deux nouveaux Collectors de Java 9 : ​​Collectors.filtering et Collectors.flatMapping, qui sont principalement utilisés pour fournir des collections d'éléments intelligents avec Collectors.groupingBy.

La méthode Collectors.filtering est similaire Par rapport à la méthode Stream filter(), cette dernière est utilisée pour filtrer les éléments d'entrée, mais leurs scénarios d'utilisation sont différents. Stream filter() est utilisé dans la méthode de chaînage de flux, tandis que la méthode Collectors.filtering est conçue pour être utilisée avec groupingBy.

Stream filter() filtre d'abord les éléments puis les regroupe. Les valeurs filtrées sont supprimées et ne peuvent pas être retracées rétroactivement. Si vous avez besoin de suivre les éléments que vous devez d'abord regrouper puis filtrer, c'est exactement ce que Collectors.filtering peut faire.
Collectors.filtering prend un paramètre de fonction pour filtrer les paramètres d'entrée, puis collecter les éléments filtrés :

@Test
public void givenList_whenSatifyPredicate_thenMapValueWithOccurences() {

List<Integer> numbers = List.of(1, 2, 3, 5, 5);

Map<Integer, Long> result = numbers.stream()
 .filter(val -> val > 3)
 .collect(Collectors.groupingBy(i -> i, Collectors.counting()));

assertEquals(1, result.size());

result = numbers.stream()
 .collect(Collectors.groupingBy(i -> i,
  Collectors.filtering(val -> val > 3, Collectors.counting())));

assertEquals(4, result.size());
}

Méthode Collectors.flatMapping

Collectors.flatMapping est similaire à la méthode Collectors.mapping, mais plus granulaire. Les deux prennent une fonction et un paramètre de collecteur pour collecter des éléments, mais la fonction flatMapping reçoit un flux d'éléments puis effectue une opération d'accumulation via le collecteur. Tout d'abord, regardons la classe modèle : la méthode

class Blog {

private String authorName;
private List<String> comments = new ArrayList<>();

public Blog(String authorName, String ... comment){
  this.authorName = authorName;
  comments.addAll(Arrays.asList(comment));
}

public String getAuthorName(){
  return this.authorName;
}

public List<String> getComments(){
  return comments;
}
}

Collectors.flatMapping ignore la collection intermédiaire et écrit directement dans un conteneur de mappage de groupe unique défini par Collectors.groupingBy :

@Test
public void givenListOfBlogs_whenAuthorName_thenMapAuthorWithComments() {

Blog blog1 = new Blog("1", "Nice", "Very Nice");
Blog blog2 = new Blog("2", "Disappointing", "Ok", "Could be better");
List<Blog> blogs = List.of(blog1, blog2);
   
Map<String, List<List<String>>> authorComments1 = blogs.stream()
 .collect(Collectors.groupingBy(Blog::getAuthorName, 
  Collectors.mapping(Blog::getComments, Collectors.toList())));
  
assertEquals(2, authorComments1.size());
assertEquals(2, authorComments1.get("1").get(0).size());
assertEquals(3, authorComments1.get("2").get(0).size());

Map<String, List<String>> authorComments2 = blogs.stream()
 .collect(Collectors.groupingBy(Blog::getAuthorName, 
  Collectors.flatMapping(blog -> blog.getComments().stream(), 
  Collectors.toList())));

assertEquals(2, authorComments2.size());
assertEquals(2, authorComments2.get("1").size());
assertEquals(3, authorComments2.get("2").size());
}

Collectors.mapping mappe toutes les valeurs de regroupement (commentaires de l'auteur). ​collectés dans un conteneur, tel que List. Et supprimez la collection intermédiaire et stockez la collection directement dans le conteneur du collecteur.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!