Java 8流：替换流集合中的单个项目

Question

I'm somewhat new to working in Java 8, and am refactoring some older code with (what appears to be a good use case for) a stream operation. The older code "works" but to my eyes it looks really inefficient.

The short version of my question is that I'm trying to find a single element of a List and replace it with an updated version of that same element (the key is the same, but properties have different values each time the code is called).

     try
     {
        List<Object> items = lookup(itemCache.getKey());
        for (int i = 0; i < items.size(); i++)
        {
           Object originalObject = items.get(i);
           if (originalObject.getPropValue() == newObject.getPropValue())
           {
              List<Object> newItems = new ArrayList<>(items);
              newItems.set(i, newObject);
              putIntoCache(newObject.getKey(), newItems);
              break;
           }
        }
     } 

     catch (Exception ex) { /*exception handling*/ }

Based on what I've read about streams thus far, it seems that I need to use a .map() or .filter() to isolate the element I want to identify, but that also seems like operations occurring after either filter or map in the stream statement would be operating on either not the full List or on a List where every item is affected by the .map() .

It seems simple, but I am struggling to wrap my head around it. Because the initial lookup is a List itself, I was thinking the stream could replace all of this. The ArrayList<>() appears in the original code, but ordering of the items isn't important so long as I am able to replace that item by its key.

If you choose to help, thank you.

Answer 1

You can simply do:

List<Object> newItems = items.stream()
    .map(o -> o.getPropValue() == newObject.getPropValue() ? newObject : o)
    .collect(toList());
putIntoCache(newObject.getKey(), newItems);

Answer 2

The function you want to apply is "replace the first element that matches the prop value". The first part (and break statement) are non-trivial (as you depend on all entries processed before that). In other words, it implies that your function depends on some additional state, so the domain can be expressed as boolean * String , where boolean tells you whether the replacement had been done. You can see it starts to get ugly.

If you are okay with replacing all matching values, then Jean Logeart's answer seems okay.

Answer 3

Streams are actually not particularly good for this snippet of code because it has an early break and simultaneously works with both indexes and elements.

You can build an equivalent statement like this:

List<Object> items = lookup(itemCache.getKey());
IntStream.range(0, items.size())
    .filter(i -> items.get(i).getPropValue() == newItem.getPropValue())
    .findFirst()
    .ifPresent(i -> {
        List<Object> newItems = new ArrayList<>(items);
        newItems.set(i, newObject);
        putIntoCache(newObject.getKey(), newItems);
    });

Is that really better? In my opinion, not particularly. We aren't really using any of the stream features, just replacing control flow syntax with API.

If the exact behavior is less important, then there are possibly better examples, like Jean's answer.