利用 Java stream API 从持有可流 collections 本身的对象中检索数据

Question

Problem statement

In my architecture there are data objects which I intend to display in a structured fashion. These objects look like this:

public class A
{
   private final String a1;

   public A( String a1 )
   {
      this.a1 = a1;
   }

   public String getA1()
   {
      return a1;
   }
}

public class B
{
   private final String b1;
   private final List<A> bList;

   public B( String b1, List<A> list )
   {
      this.b1 = b1;
      this.bList = list;
   }

   public String getB1()
   {
      return b1;
   }

   public List<A> getBList()
   {
      return bList;
   }
}

public class C
{
   private final String c1;
   private final int c2;
   private final List<B> cList;

   public C( String c1, int c2, List<B> list )
   {
      this.c1 = c1;
      this.c2 = c2;
      this.cList = list;
   }

   public String getC1()
   {
      return c1;
   }

   public int getC2()
   {
      return c2;
   }

   public List<B> getCList()
   {
      return cList;
   }
}

So an object C holds some values, as well as a list of objects B and those objects B hold some values of their own as well as respectively a list of objects A , which in turn hold some values themselves.

The requirements I am trying to comply with are putting these into a JSON structure and also create a list of objects, where every entry looks like a collection of all of those data properties in a single object . The latter is supposed to look like this:

public class D
{
   public final String a1;
   public final String b1;
   public final String c1;
   public final int c2;

   public D( String a1, String b1, String c1, int c2 )
   {
      this.a1 = a1;
      this.b1 = b1;
      this.c1 = c1;
      this.c2 = c2;
   }
}

The declared goal is to have those collected in a List<D> .

My solutions so far

The JSON structuring was easy to accomplish with Jackson:

C c = someGetterForC();
ObjectMapper mapper = new ObjectMapper();
mapper.enable( SerializationFeature.INDENT_OUTPUT );
try
{
   return mapper.writeValueAsString( c );
}
catch( JsonProcessingException e )
{
   // do error handling here
}

This gives me a well formatted JSON string and complies with the first requirement. For the second requirement I initially used a very trivial approach, ie simply to collect all data in for -loops, thereby creating instances of D and putting them in a list. This looked somewhat like this:

List<D> dList = new ArrayList<>();
C c = someGetterForC();
for( B b : c.getCList() )
{
   for( A a : b.getBList() )
   {
      D d = new D( a.getA1(), b.getB1(), c.getC1(), c.getC2() )
      dList.add( d );
   }
}

However I would like to learn to do this using Java-Streams in order to create instances of D , because I am still having trouble with understanding some of its concepts. The struggle I am facing is with

• Streaming the list of objects A after streaming lists of object B
• Accessing non-list members from A , B and C in the same call and collecting them in instances of D

Can this be done in a single stream-API call, ie

C c = someGetterForC();
c.stream()
// how to continue?

and if so, does it make sense to do so?

Notes

• Java 11 is mandatory, the project has currently no access to newer Java data structures
• The fact that given the for -loops there will be redundant data in the instances of D is of no concern and intended

Example

Assume there is an object C c_alpha which holds:

c1 = "car"
c2 = 42;
cList = {b_alpha, b_beta}

Where B b_alpha holds:

b1 = "boulder"
bList = {a_alpha}

And B b_beta holds:

b1 = "bomb"
bList = {a_beta, a_gamma}

Lastly there are the type A objects left, A a_alpha holds:

a1 = "ape"

A a_beta holds:

a1 = "andromeda"

And A a_gamma holds:

a1 = "axe"

Then the collected list of objects D that I am trying to get by leveraging the stream-API should look like this:

{ "42", "car", "boulder", "ape" },
{ "42", "car", "bomb", "andromeda" },
{ "42", "car", "bomb", "axe" },

TL;DR

Given objects which hold primitive types + strings as members, as well as lists of objects, which in turn hold primitive types + strings as members as well as lists of objects - how to stream them in a single call to retrieve tuples of the primitive types + strings accross all types in a single call?

I realize this is hard to properly formulate, the example above should clear things up.

Answer 1

In order to get the same result as with your classical for-loop approach you need to use flatMap . Get the list of B s from your object and stream over it, flatmap and get every A for each B by calling getBList() and map the data to a new D object and finally collect to list of D objects. Something like below should give you what you are looking for

C c = someGetterForC();

List<D> dList = c.getCList()
                 .stream()
                 .flatMap(b -> b.getBList()
                                .stream()
                                .map(a -> new D(a.getA1(), b.getB1(), c.getC1(), c.getC2())))
                 .collect(Collectors.toList());