Getting only required objects from a list using Java 8 Streams

前端 未结 3 2044
余生分开走
余生分开走 2021-02-14 19:12

Consider a Parent class with the attributes attrib1, attrib2 and List child with its corresponding getters and s

相关标签:
3条回答
  • 2021-02-14 19:20

    As I can understand you should add additional filter for child lists:

     parent.stream().filter(e -> e.getChild().stream().anyMatch(c -> c.getAttrib1() > 10)).forEach(e -> e.setChild(e.getChild().stream().filter(c -> c.getAttrib1 > 10).collect(toList())))
    

    If you have not setChild:

    • You can remove items from lists
    • Create completly new parent objects

    To remove you can use iterator:

    parent.stream().filter(e -> e.getChild().stream().anyMatch(c -> c.getAttrib1 > 10))
       .forEach(e -> {
          for(Iterator<Child> it = e.getChild().iterator(); it.hasNext();){
              Child cur = it.next();
              if(cur.getAttrib1() <= 10) it.remove();
        }
    })
    
    0 讨论(0)
  • 2021-02-14 19:22

    What you need is a Stream<Child> if you want to receive all children. The following expression might do the trick:

    parents.stream().flatMap(e -> e.getChildren().stream()).filter(c -> c.getAttrib1() > 10)

    This should return all children of all parents in the list where the get attribute value is greater than 10.

    If you want to update the parents list by removing all child elements that fail a condition, you can do the following:

    parents.forEach(p -> p.getChildren().removeIf(c -> c.getAttrib1() > 10));

    This doesn't create a new list. Instead it updates the parents list itself.

    0 讨论(0)
  • 2021-02-14 19:23

    I know the question is almost 2 years old, but hopefully this answer can help someone.

    There's a library called com.coopstools.cachemonads. It extends the java stream (and Optional) classes to allow caching of entities for later use.

    The solution can be found with:

    List<Parent> goodParents = CacheStream.of(parents)
                .cache()
                .map(Parent::getChildren)
                .flatMap(Collection::stream)
                .map(Child::getAttrib1)
                .filter(att -> att > 10)
                .load()
                .distinct()
                .collect(Collectors.toList());
    

    where, parents is an array or stream.

    For clarity, the cache method is what stores the parents; and the load method is what pulls the parents back out. And If a parent does not have children, a filter will be needed after the first map to remove the null lists.

    This library can be used in any situation where operations need to be performed on children, including map/sort/filter/etc, but where an older entity is still needed.

    The code can be found at https://github.com/coopstools/cachemonads (where I've included your example in the readme), or can be downloaded from maven:

    <dependency>
        <groupId>com.coopstools</groupId>
        <artifactId>cachemonads</artifactId>
        <version>0.2.0</version>
    </dependency>
    

    (or, gradle, com.coopstools:cachemonads:0.2.0)

    0 讨论(0)
提交回复
热议问题