Java 8 - chaining constructor call and setter in stream.map()

Question

I have a class

class Foo{     String name;     // setter, getter } 

which just has a default constructor.

Then, I am trying to create a List of Foo from some string:

Arrays.stream(fooString.split(","))             .map(name -> {                 Foo x = new Foo();                 x.setName(name);                 return x;              }).collect(Collectors.toList())); 

Since there is no constructor which takes a name, I can't simply use a method reference. Of course, I could extract those three lines, with the constructor call and the setter, into a method but is there any better or concise way to do that? (without changing Foo, which is a generated file)

Answer 1

If this happens repeatedly, you may create a generic utility method handling the problem of constructing an object given one property value:

public static <T,V> Function<V,T> create(     Supplier<? extends T> constructor, BiConsumer<? super T, ? super V> setter) {     return v -> {         T t=constructor.get();         setter.accept(t, v);         return t;     }; } 

Then you may use it like:

List<Foo> l = Arrays.stream(fooString.split(","))     .map(create(Foo::new, Foo::setName)).collect(Collectors.toList()); 

Note how this isn’t specific to Foo nor its setName method:

List<List<String>> l = Arrays.stream(fooString.split(","))     .map(create(ArrayList<String>::new, List::add)).collect(Collectors.toList()); 

---

By the way, if fooString gets very large and/or may contain lots of elements (after splitting), it might be more efficient to use Pattern.compile(",").splitAsStream(fooString) instead of Arrays.stream(fooString.split(",")).

Answer 2

No, there is no better way.

The only alternative is, like you said in your question, to create a factory for Foo objects:

public class FooFactory {     public static Foo fromName(String name) {         Foo foo = new Foo();         foo.setName(name);         return foo;     } } 

and use it like this:

Arrays.stream(fooString.split(",")).map(FooFactory::fromName).collect(toList()); 

If there are a lot of names to split, you can use Pattern.compile(",").splitAsStream(fooString) (and store the compiled pattern in a constant to avoid recreation) instead of Arrays.stream(fooString.split(",")).