如何收集/减少java 8流到pojo？

Question

Look at the code:

Collection<MyDto> col = ...

MyBuilder builder = new MyBuilder(); 
for (MyDto dto: col) {
    switch (dto.getType()) {
        case FIELD1:
            builder.field1(dto.getValue());
            break:
        case FIELD2:
            builder.field2(dto.getValue());
            break:
    }    
}

Some result = builder.build();

Is there a way to do this with streams, like:

Some result = col.stream().collect(...)

Note that all stream values are collected into sigle pojo, not collection, stream or map.

Answer 1

The bottom line is that somewhere, somehow, you need to map the possible return values of MyDto.getType() to property setting methods of MyBuilder . Your code does that via a switch statement, and that's just fine . You can write the reduction as a stream-based pipeline instead, but you still need to incorporate the mapping somehow.

A pretty direct way of doing that would be to construct a literal Map , which could be made static, final, and unmodifiable. For instance, if you're starting with classes structured like so ...

class Some {
}

class MyBuilder {
    void field1(String s) { }
    void field2(String s) { }
    void field3(String s) { }
    Some build() {
        return null;
    }
}

class ValueType {}

class MyDto {
    int type;
    ValueType value;

    int getType() {
        return type;
    }

    ValueType getValue() {
        return value;
    }
}

... then you might set up the reduction you describe like this:

public class Reduction {

    // Map from DTO types to builder methods
    private final static Map<Integer, BiConsumer<MyBuilder, ValueType>> builderMethods;

    static {
        // one-time map initialization
        Map<Integer, BiConsumer<MyBuilder, ValueType>> temp = new HashMap<>();
        temp.put(FIELD1, MyBuilder::field1);
        temp.put(FIELD2, MyBuilder::field2);
        temp.put(FIELD3, MyBuilder::field3);
        builderMethods = Collections.unmodifiableMap(temp);
    }

    public Some reduce(Collection<MyDto> col) {
        return col.stream()
                  // this reduction produces the populated builder
                  .reduce(new MyBuilder(),
                          (b, d) -> { builderMethods.get(d.getType()).accept(b, d); return b; })
                  // obtain the built object
                  .build();
    }
}

That particular implementation uses a new builder every time, but it could be modified to instead use a builder passed into Reduction.reduce() via a parameter, in case you want to start with some properties pre-populated, and / or retain a record of the properties with which the returned object was built.

Finally, note well that although you can hide the details in one place or another, I don't see any scope to make the overall process any simpler than the switch -based code you started with.

Answer 2

I did not compile this, but just to give you an idea:

 Map<Boolean, List<MyDto>> map = col.stream().collect(Collectors.partitioningBy(t -> t.getType() == FIELD2));

 map.get(false).forEach(x -> builder.field1(x.getValue()))

 map.get(true).forEach(x -> builder.field2(x.getValue()))

Answer 3

Assuming two MyBuilder instances are capable of being combined/merged then you can do this with a Collector .

public class MyCollector implements Collector<MyDto, MyBuilder, Result> {

    @Override 
    public Supplier<MyBuilder> supplier() {
        return MyBuilder::new;
    }

    @Override
    public BiConsumer<MyBuilder, MyDto> accumulator() {
        return (builder, dto) -> {
            // Add "dto" to "builder" based on type
        };
    }

    @Override
    public BinaryOperator<MyBuilder> combiner() {
        return (left, right) -> left.merge(right);
    }

    @Override
    public Function<MyBuilder, Result> finisher() {
        return MyBuilder::build;
    }

    @Override
    public Set<Characteristics> characteristics() {
        return Set.of();
    }

}

Then you could do:

Collection<MyDto> col = ...;
Result r = col.stream().collect(new MyCollector());

If you don't want to make a custom implementation of Collector you can use Collector.of(...) .

---

A different, maybe more maintainable, way to do this is to have the builder do all the work. This way all the mapping logic is in one place.

public class ResultBuilder {

    public static Collector<MyDto, ?, Result> resultCollector() {
        return Collector.of(ResultBuilder::new, ResultBuilder::add,
                ResultBuilder::merge, ResultBuilder::build);
    }

    public ResultBuilder add(MyDto dto) {
        // Do what is needed based on the type of "dto"
        return this;
    }

    public ResultBuilder merge(ResultBuilder other) {
        // Merge "other" into "this"
        return this;
    }

    public Result build() {
        // Build result and return it
    }

}

Then you could use the builder with or without streams. With streams is very similar to before:

Collection<MyDto> col = ...;
Result r = col.stream().collect(ResultBuilder.resultCollector());

Answer 4

And now, for a depressingly boring answer:

Don't do this.

Using streams to effectively map across like this makes your code less readable and maintainable in the future. It is ill-advised to use this Java 8 feature for this purpose.

It absolutely can be done, as some answerers have pioneered, but that doesn't necessarily mean it should be done.

More concisely, your initial premise is that you can capture all of your fields in some kind of enum or structure you can switch on, which breaks every time you introduce or remove a field, which can be time consuming to track down. Clever ways of getting the fields out with reflection may be slightly more flexible, but then you're in a more rigid setup with reflection than you may realize; if you want to map 1 to 1 this works fine, but if you want to do some data transformation, you have to be very careful about how you tweak your mapper.

All of that to say...

Use a mapping framework instead like MapStruct or Dozer .

Answer 5

Your main problem is that the mapping of each MyBuilder method to each MyDto type is arbitrary, ie there's no way for Java to automatically know which method to call for each type: you have to tell Java which is which.

So, if each method of the builder is mapped to a different dto.getType() value, the simplest way of telling Java, is moving that switch to a general method inside MyBuilder that lets you inform the appropriate field, like this:

public MyBuilder fieldFromDto(MyDto dto) {
    switch (dto.getType()) {
        case FIELD1: return field1(dto.getValue);
        case FIELD2: return field2(dto.getValue);
        //...

So then you could do just this:

MyBuilder builder = new MyBuilder();
col.stream().forEach(builder::fieldFromDto);
Some result = builder.build();

Another possibility would be to turn that switch into a lambda map ( Type and Value being the types of MyDto 's fields):

class MyBuilder {
    public final Map<Type, Function<Value, MyBuilder>> mappings = new Map<>();
    public MyBuilder() {
        mappings.put(FIELD1, this::field1);
        mappings.put(FIELD2, this::field2);
        //...
    }

And then use those lambdas in a forEach :

MyBuilder builder = new MyBuilder();
col.stream().forEach(dto -> builder.mappings.get(dto.getType()).apply(dto.getValue()));
Some result = builder.build();

Other than that, you could use reflection like some other answers proposed, but then you need to make sure that FIELD1 , FIELD2 etc. are actual MyBuilder method names, losing some flexibility.

In the end I wouldn't recommend doing any of the above. Streams are great, but sometimes they don't offer any advantage over a normal for loop and can make your code uglier and difficult to maintain.