Java：获取class成员列表，用于多级嵌套列表中的列表

Question

. Answers to this question are eligible for a +50 reputation bounty. mattsmith5 is looking for an .

In Java, how do I map and obtain a class member list, using a list within list.

public class CustomerSales {
    public List<Product> productList;
    ....
}

public class Product {
    public List<ProductSubItem> productSubItemList
    ....
}

public class ProductSubItem {
    public String itemName;

Attempt:

However, this does not get the itemName. looking for a clean efficient method, ideally may want to attempt 4-5 levels deep, however question has only 3 for simplicity, etc

List<String> itemNameList = customerSales.productList.stream().map(p -> p.productSubItemList()).collect(Collectors.toList()); 

using Java 8

Attempted using this resource: still not luck, How can I get a List from some class properties with Java 8 Stream?

Answer 1

Convert sub-list to a stream and use flatMap to convert stream of streams of elements to stream of elements.

Example:

package x.mvmn.demo;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class Demo {

    public static class CustomerSales {
        public List<Product> productList;
    }

    public static class Product {
        public List<ProductSubItem> productSubItemList;

        public List<ProductSubItem> getProductSubItemList() {
            return productSubItemList;
        }
    }

    public static class ProductSubItem {
        public String itemName;

        public ProductSubItem(String itemName) {
            this.itemName = itemName;
        }

        public String getItemName() {
            return itemName;
        }
    }

    public static void main(String args[]) throws Exception {
        // Setup mock data
        CustomerSales customerSales = new CustomerSales();
        Product p1 = new Product();
        p1.productSubItemList = Arrays.asList(new ProductSubItem("p1 item one"), new ProductSubItem("p1 item two"));
        Product p2 = new Product();
        p2.productSubItemList = Arrays.asList(new ProductSubItem("p2 item one"), new ProductSubItem("p2 item two"));
        customerSales.productList = Arrays.asList(p1, p2);

        // Get list of item names
        System.out.println(customerSales.productList.stream().map(Product::getProductSubItemList).flatMap(List::stream)
                .map(ProductSubItem::getItemName).collect(Collectors.toList()));
        // Alternative syntax
        System.out.println(customerSales.productList.stream().flatMap(product -> product.productSubItemList.stream())
                .map(subItem -> subItem.itemName).collect(Collectors.toList()));
    }
}

Output:

[p1 item one, p1 item two, p2 item one, p2 item two]
[p1 item one, p1 item two, p2 item one, p2 item two]

Answer 2

Looks like you need to use flatMap:

https://www.baeldung.com/java-difference-map-and-flatmap

List<String> itemNameList = customerSales.productList.stream().map(p -> p.productSubItemList().stream()).collect(Collectors.toList()); 

---

Here is another example of flattening list of lists https://www.baeldung.com/java-flatten-nested-collections

public <T> List<T> flattenListOfListsStream(List<List<T>> list) {
    return list.stream()
      .flatMap(Collection::stream)
      .collect(Collectors.toList());    
}

Answer 3

We can re-write the @mvmn answer using below.

public class Demo {

    public static class CustomerSales {
        public List<Product> productList;

        public Stream<Product> getProductStream() {
            return !CollectionUtils.isEmpty(productList) ? productList.stream() : Stream.empty();
        }
    }

    public static class Product {
        public List<ProductSubItem> productSubItemList;

        public List<ProductSubItem> getProductSubItemList() {
            return productSubItemList;
        }

        public Stream<ProductSubItem> getProductSubItemStream() {
            return !CollectionUtils.isEmpty(productSubItemList) ? productSubItemList.stream() : Stream.empty();
        }
    }

    public static class ProductSubItem {
        public String itemName;

        public ProductSubItem(String itemName) {
            this.itemName = itemName;
        }

        public String getItemName() {
            return itemName;
        }
    }

    public static void main(String args[]) throws Exception {
        // Setup mock data
        CustomerSales customerSales = new CustomerSales();
        Product p1 = new Product();
        p1.productSubItemList = Arrays.asList(new ProductSubItem("p1 item one"), new ProductSubItem("p1 item two"));
        Product p2 = new Product();
        p2.productSubItemList = Arrays.asList(new ProductSubItem("p2 item one"), new ProductSubItem("p2 item two"));
        customerSales.productList = Arrays.asList(p1, p2);

        // With Utility method in our DTOs
        System.out.println(customerSales.getProductStream()
                                        .flatMap(Product::getProductSubItemStream)
                                        .map(ProductSubItem::getItemName)
                                        .collect(Collectors.toList()));

        // Java16+
        System.out.println(customerSales.getProductStream()
                                        .flatMap(Product::getProductSubItemStream)
                                        .map(ProductSubItem::getItemName)
                                        .toList());
    }
}

Answer 4

In case when you need to perform a one-to-one transformation - use map() operation. For one-to-many transformations, use flatMap() operation.

flatMap() expects a Function which consumes a stream and produces a Stream of resulting type.

Java 16 offers one more alternative for one-to-many transformations, namely mapMulti() , which would be more beneficial in terms of performance ( because it doesn't require generating a new Stream internally like flatMap does ) if the associated collection is expected to contain of a few elements or even might be empty. If you can't predict the number of elements in the resulting stream, then flatMap() is the way to go.

However, this does not get the itemName. looking for a clean efficient method, ideally may want to attempt 4-5 levels deep

To tackle the scenario, you've described, you can introduce a uniform method producing a Function which turns a stream element into another stream (a Function required by the flatMap ), and utilize this method in the Stream for the purpose of conciseness.

public static <T, R> Function<T, Stream<R>> flatten(
    Function<T, ? extends Collection<R>> mapper
) {
    return t -> mapper.apply(t).stream();
}

Now let's consider the following object-graph with a diversity of nested collections:

ClassA -> List<ClassB>
ClassB -> Set<ClassC>
ClassC -> Map<Integer, ClassD> mapD
ClassD -> Queue<ClassE> queueE
ClassE -> String name

If we have a List of ClassA instances, the List name from ClassE can be obtained in the following way:

List<String> names = aList.stream()              // Stream<ClassA>
    .flatMap(flatten(ClassA::getListB))          // Stream<ClassB>
    .flatMap(flatten(ClassB::getSetC))           // Stream<ClassC>
    .flatMap(flatten(c -> c.getMapD().values())) // Stream<ClassD>
    .flatMap(flatten(ClassD::getQueueE))         // Stream<ClassE>
    .map(ClassE::getName)                        // Stream<String>
    .toList(); // for Java 16 or collect(Collectors.toList()

Here's a complete example.

Dummy classes:

public class ClassA {
    private List<ClassB> listB;
    
    // getters, all-args constructor
}

public class ClassB {
    private Set<ClassC> setC;

    // getters, all-args constructor
}

public class ClassC {
    private Map<Integer, ClassD> mapD;

    // getters, all-args constructor
}

public class ClassD {
    private Queue<ClassE> queueE;

    // getters, all-args constructor
}

public class ClassE {
    private String name;

    // getters, all-args constructor
}

main()

public static void main(String[] args) {
    List<ClassA> aList = List.of(new ClassA(
        List.of(
            new ClassB(
                Set.of(
                    new ClassC(Map.of(
                        1, new ClassD(new ArrayDeque<>(List.of(new ClassE("Alice")))),
                        2, new ClassD(new ArrayDeque<>(List.of(new ClassE("Bob"))))
                    )),
                    new ClassC(Map.of(1, new ClassD(new ArrayDeque<>(List.of(new ClassE("Carol"))))))
                )
            )
        )
    ));
    
    List<String> names = aList.stream()
        .flatMap(flatten(ClassA::getListB))
        .flatMap(flatten(ClassB::getSetC))
        .flatMap(flatten(c -> c.getMapD().values()))
        .flatMap(flatten(ClassD::getQueueE))
        .map(ClassE::getName)
        .toList(); // for Java 16 or collect(Collectors.toList()

    System.out.println(names);
}

Output:

[Alice, Bob, Carol]

A link to Online Demo