Java lambda expression -- mapping and then modifying a list?

Question

Using a Java 8 lambda expression, I'm trying to do something like this.

List<NewObject> objs = ...;
for (OldObject oldObj : oldObjects) {
  NewObject obj = oldObj.toNewObject();
  obj.setOrange(true);
  objs.add(obj);
}

I wrote this code.

oldObjects.stream()
  .map(old -> old.toNewObject())
  .forEach({new.setOrange("true")})
  .collect(Collectors.toList());

This is invalid code because I'm then trying to do .collect() on what's returned by .forEach(), but forEach is void and does not return a list.

How should this be structured?

rgettman · Accepted Answer · 2015-11-06 00:22:10Z

7

You can use Stream's peek method, which returns the Stream because it's an intermediate operation. It normally isn't supposed to have a side effect (it's supposed to be "non-interfering"), but in this case, I think the side effect (setOrange(true)) is intended and is fine.

List<NewObject> newObjects =
    oldObjects.stream()
        .map(OldObject::toNewObject)
        .peek( n -> n.setOrange(true))
        .collect(Collectors.toList());

It's about as verbose as your non-streams code, so you can choose which technique to use.

answered Nov 6, 2015 at 0:22

rgettman

179k30 gold badges282 silver badges365 bronze badges

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

3 Comments

Brian Goetz Over a year ago

There's a difference between side-effect-free and non-interfering. (Note that a void-returning lambda can only have side-effects, except for the trivial e -> {} consumer.) Determining that the lambda passed to peek actually is non-interfering is not always trivial (though what you've got here looks harmless enough.)

ZhongYu Over a year ago

it's not more interfering than peek( n -> print(n) )

Holger Over a year ago

@bayou.io: this is not correct. Mutating a property of a stream element can be interfering, e.g. if the same element appears multiple times within the same stream. This is different to a print operation. But since oldObj.toNewObject() seems to create new instances we can conclude that this is not the case here. However, it still would be cleaner to construct the NewObject instance and set the orange property in one lambda within the map operation. Then, peek would be unnecessary.

Paul Boddington · Accepted Answer · 2015-11-06 00:32:55Z

5

You can use peek.

List<NewObject> list = oldObjects.stream()
                                 .map(OldObject::toNewObject)
                                 .peek(o -> o.setOrange(true))
                                 .collect(Collectors.toList());

Alternatively, you can mutate the elements after forming the list.

List<NewObject> list = oldObjects.stream()
                                 .map(OldObject::toNewObject)
                                 .collect(Collectors.toList());
list.forEach(o -> o.setOrange(true));

edited Nov 6, 2015 at 0:32

answered Nov 6, 2015 at 0:22

Paul Boddington

37.8k10 gold badges69 silver badges120 bronze badges

Collectives™ on Stack Overflow

Java lambda expression -- mapping and then modifying a list?

2 Answers 2

3 Comments

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

3 Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related