Filter on nested list using Java 8 Stream API

Question

I'm not able to convert below snippet in Java 8 stream format.

List<String> titles = Arrays.asList("First Name", "Last Name");

for (FirstClass first : firstClassList) {
    for (SecondClass second : first.getSecondClassList()) {
        for (ThirdClass third : second.getThirdClassList()) {                   

            if(!titles.contains(third.getField())) {
                second.getThirdClassList().remove(third);
            }

        }
    }
}

I'm comparing third level nested list object against the input list of fields. If fields are not matching then I'm removing them from original list. How can I achieve this using Java 8 syntax.

Edit: I want List of FirstClass to be returned.

Stream#flatMap and Stream#filter methods could help for this scenario — user10386912
– user10386912, Commented Apr 22, 2019 at 10:17
To use streams instead of the for loops you want to flatten the data-structure, i.e. something like firstClassList.stream().flatMap(FirstClass::getSecondClassList() and similar for the second level. — stridecolossus
– stridecolossus, Commented Apr 22, 2019 at 10:17
This code doesn't work, it throws ConcurrentModificationException — fps
– fps, Commented Apr 22, 2019 at 15:21

Misha · Accepted Answer · 2019-04-22 18:39:35Z

3

I don't think streams win you anything in this case. All you do is iterate over the nested lists and either the enhanced for loop or forEach is more straightforward.

The improvements can come from using removeIf to modify the list and, possibly, from moving the rejection logic out of the loop:

Predicate<ThirdClass> reject = third -> !titles.contains(third.getField());

firstClassList.forEeach(first ->
    first.getSecondClassList().forEach(second ->
        second.getThirdClassList().removeIf(reject)
    )
);

answered Apr 22, 2019 at 18:39

Misha

28.3k7 gold badges66 silver badges83 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

Samuel Philipp · Accepted Answer · 2019-04-22 19:52:14Z

First you can use Stream.map() and Stream.flatMap() to get a Stream containing a List of ThirdClass. To remove the items matching the condition you could use Collection.removeIf(), which removes all items from a collection matching the given condition:

firstClassList.stream()                         // Stream<FirstClass>
        .map(FirstClass::getSecondClassList)    // Stream<List<SecondClass>>
        .flatMap(Collection::stream)            // Stream<SecondClass>
        .map(SecondClass::getThirdClassList)    // Stream<List<ThirdClass>>
        .forEach(thirdList -> thirdList.removeIf(third -> !titles.contains(third.getField())));

This modifies the original List, just like you did in your example. You then can use firstClassList as result for further processing.

Beside that I would recommend using a Set<String> instead of a List<String> for your titles, because it has a time complexity of O(1) instead of O(n):

Set<String> titles = new HashSet<>(Arrays.asList("First Name", "Last Name"));

score 1 · Accepted Answer · 2019-04-22 15:07:30Z

1

Get a stream of SecondClass objects by flattening the firstClassList and for each SecondClass get the filtered list of ThirdClass objects and set it back in the SecondClass

List<String> titles = Arrays.asList("First Name", "Last Name");

firstClassList
    .stream()
    .flatMap(firstClass -> firstClass.getSecondClassList().stream())
    .forEach(secondClass -> {
             List<ThirdClass> filteredThirdClasses = secondClass.getThirdClassList()
                        .stream()
                        .filter(thirdClass -> titles.contains(thirdClass.getField()))
                        .collect(toList());

             secondClass.setThirdClassList(filteredThirdClasses);
         }
    );

edited Apr 22, 2019 at 15:07

answered Apr 22, 2019 at 10:55

user10386912

Comments

stridecolossus · Accepted Answer · 2019-04-22 10:24:56Z

0

Assuming the three levels in your data-structure are collections then a solution could be:

flatten the structure to a stream of the leaf level
filter by the required titles

final List<ThirdClassList> results = firstClassList
    .stream()
    .flatMap(FirstClassList::getSecondClassList)
    .flatMap(FirstClassList::getThirdClassList)
    .filter(third -> !titles.contains(third))
    .collect(toList());

This will give you the leaf level objects to be removed, though this is only half the solution of course, you still want to remove them.

If you are the author of the list classes then perhaps you could have a reference from each third level to its 'parent' second level so removing is then a relatively simple second step:

results.forEach(third -> third.parent().remove(this));

where third.parent() returns the second level object.

answered Apr 22, 2019 at 10:24

stridecolossus

1,58113 silver badges26 bronze badges

2 Comments

Izruo Over a year ago

For performance, you could change the intermediate List to Stream#iterator() and Iterator#remove() - as long as the final Stream supports element removal.

pri Over a year ago

stridecolossus, thanks for your response. But I need FirstClass List instead of leaf.

Collectives™ on Stack Overflow

Filter on nested list using Java 8 Stream API

4 Answers 4

Comments

Comments

Comments

2 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

4 Answers 4

Comments

Comments

Comments

2 Comments

Your Answer

Sign up or log in

Post as a guest

Related