We Keep Coding

How to apply flatMap() to implement the following logic with Streams

I have the following for loop:
List<Player> players = new ArrayList<>();
for (Team team : teams) {
ArrayList<TeamPlayer> teamPlayers = team.getTeamPlayers();
for (teamPlayer player : teamPlayers) {
players.add(new Player(player.getName, player.getPosition());
}
}
and I'm trying to convert it to a Stream:
List<Player> players = teams.forEach(t -> t.getTeamPlayers()
.forEach(p -> players.add(new Player(p.getName(), p.getPosition())))
);
But I'm getting a compilation error:
variable 'players' might not have been initialized
Why is this happening? Maybe there's an alternative way to create the stream, I was thinking of using flatMap but not sure how to apply it.

First of all, you need to understand that Streams don't act like Loops.
Hence, don't try to mimic a loop. Examine the tools offered by the API. Operation forEach() is there for special cases when you need to perform side-effects, not in order to accumulate elements from the stream into a Collection.
Note: with teams.forEach() you're not actually using a stream, but method Iterable.forEach() which is available with every implementation of Iterable.
To perform reduction on streams, we have several specialized operations like collect, reduce, etc. (for more information refer to the API documentation - Reduction).
collect() operation is meant to perform mutable reduction. You can use to collect the data into a list by providing built-in Collector Collectors.toList() as an argument. And since Java 16 operation toList() was introduced into API, which is implemented on top of the toArray() operation and performs better than namesake collector (therefore it's a preferred option if your JDK version allows you to use it).
I was thinking of using flatMap but not sure how to apply it.
Operation flatMap() is meant to perform one-to-many transformations. It expects a Function which takes a stream element and generates a Stream of the resulting type, elements of the generated stream become a replacement for the initial element.
Note: that general approach to writing streams to use as fewer operations as possible (because one of the main advantages that Functional programming brings to Java is simplicity). For that reason, applying flatMap() when a stream element produces a Collection in a single step is idiomatic, since it's sorter than performing map().flatMap() in two steps.
That's how implementation might look like:
List<Team> teams = List.of();
List<Player> players = teams.stream() // Stream<Team>
.flatMap(team -> team.getTeamPlayers().stream()) // Stream<Player>
.map(player -> new Player(player.getName(), player.getPosition()))
.toList(); // for Java 16+ or collect(Collectors.toList())

This is basically the answer of Alexander Ivanchenko, but with method reference.
final var players = teams.stream()
.map(Team::getTeamPlayers)
.flatMap(Collection::stream)
.map(p -> new Player(p.getName(), p.getPosition()))
.toList();
If your Player class has a factory method like (depending on the relation between Player and TeamPlayer:
public static Player fromTeamPlayer(final TeamPlayer teamPlayer) {
return new Player(teamPlayer.getName(), teamPlayer.getPosition());
}
You could further reduce it to:
final var players = teams.stream()
.map(Team::getTeamPlayers)
.flatMap(Collection::stream)
.map(Player::fromTeamPlayer)
.toList();

Java-Stream - Combine results of two methods producing a Value and a List invoked conditionaly inside the same stream operation in Java 8

I have two methods: funca() and funcb() which return a value of type X or a List<X> respectively like shown below:
X funca(Event e) { ... }
List<X> funcb(Event e) { ... }
I want to use them in the Stream and collect the result into a list.
These method methods should be called under different conditions, like shown below in pseudocode:
List<Event> input = // initializing the input
List<X> resultList = input.values().stream()
.(event -> event.status=="active" ? funca(event) : funcb(event))
.collect(Collectors.toList());
Can someone please tell me how I can achieve this so that whether the function returns a list of values or values?

Since one of your functions produces a Collection as a result, you need a stream operation that allows performing one-to-many transformation. For now, Stream IPA offers two possibilities: flatMap() and mapMulti().
To approach the problem, you need to take a closer look at them and think in terms of these operations.
flatMap()
This operation requires a function producing a Stream, and elements of this new stream become a replacement for the initial element.
Therefore, you need to wrap the result returned by the funca() with Singleton-Stream using Stream.of() (there's no need for wrapping the element with a List, like shown in another answer flatMap() is not capable to consume Collections).
List<X> = input.values().stream()
.flatMap(event -> "active".equals(event.getStatus()) ?
Stream.of(funca(event)) : funcb(event).stream()
)
.toList(); // for Java 16+ or collect(Collectors.toList())
mapMulti()
This operation was introduced with Java 16 and is similar to flatMap() but acts differently.
Contrary to flatMap it doesn't consume a new Stream. As an argument it expects a BiConsumer. Which in turn takes a stream element and a Consumer of the resulting type. Every element offered to the Consumer becomes a part of the resulting stream.
mapMulti() might be handy if funcb() produces a list which is very moderate in size (refer to documentation linked above for more details), otherwise flatMap() would be the right tool.
List<X> = input.values().stream()
.<X>mapMulti((event, consumer) -> {
if ("active".equals(event.getStatus())) consumer.accept(funca(event));
else funcb(event).forEach(consumer);
})
.toList(); // for Java 16+ or collect(Collectors.toList())
Sidenote: don't use == to compare reference types (like String) unless you need to make sure that both references are pointing to the same object, use equals() method instead.

Embed the result of funcA into a list and flatMap the lists:
List<X> result = input.stream()
.flatMap(e -> e.status.equals("active") ? List.of(funcA(e)) : funcB(e))
.collect(Collectors.toList());

Rewrite traditional for loop to streams.map java 8

i am trying to test a Rest API PUT request. It is a spring boot application.
PUT request is used to do an update in the existing list of objects
traditional way of writing is working.
data is the data in the memory - which is a List<Bean> and
name (string type) is the key to find the object in the data and objectBean is the one to replace once we find with the key(that is name)
public void update(Bean objectBean, String name) {
for(int i = 0; i < data.size() ; i++) {
Bean l = data.get(i);
if(l.getName().equals(name)) {
data.set(i, objectBean);
return;
}
}
};
but i tried to write using Stream in java 8 . below is the code
Data.stream().map(p -> p.getName().equals(name) ? objectBean: p );
but this gives empty list.

Using streams here makes code only more complicated.
If you really wants you can introduce it to find the index i value. After that you can do the replacement.
IntStream.range(0, data.size())
.filter(i -> data.get(i).getName().equals(name)).findFirst()
.ifPresent(i -> data.set(i, objectBean));

Given that data is some List with Bean objects, you'd need to return your collected stream:
return data.stream()
.map(bean -> bean.getName().equals(name) ? objectBean : bean)
.collect(Collectors.toList());
If data is a non-empty Iterable then the output must be as well as map takes a Function object. However, this is not a good use case for the Stream API:
Firstly, streams are designed for side-effect-free purposes (i.e., creating new data structures rather updating them). The stream API supports forEach(Consumer<super T>) which is designed for side effects, but so do many other collections, in fact, all Iterables, whereas the immutable operations such as map and flatMap are not.
Second, I can't see the rest of your program, but at least in this snippet you seem to be updating your data structure based on the name, and you assume the name is unique because you stopped as soon as you reached the first Bean with the name you're looking for. Consider using Map<String, Bean> as your data structure.
Lastly, streams are lazy data structures, meaning that all the chained operations get computed when you collect. This provides incentive to chain a lot of computations together - chaining just a single map doesn't give you any performance advantages (tho it does give you referential transparency).

return data.stream()
.filter(bean -> bean.getName().equals(name))
.findAny()

How to perform a reduction operation on some parts of a Stream

I've encountered a situation that I though possible to handle using the Stream API but I simply cannot figure out a proper solution.
The case is the following : I have a stream of elements sorted by an identifier field. There are several elements with the same value for this identifier, and I need to deduplicate them based on conditions on other fields. Conceptually, it can be seen as a reduce operation on several chunks of the stream yielding to a stream of the same type.
For now, the only solution I manage to come with, is to collect the stream based on the common identifier to obtain something like Map<Id, List<Elem>> and then use this map's stream to apply my deduplication rules and go on. The problem (and why I won't use this solution) is that collect is a terminal operation, re-streaming after it means that I will iterate over my elements twice.
UPDATE
Consider the following class :
public static class Item {
private final int _id;
private final double _price;
public Item(final int id, final double price) {
_id = id;
_price = price;
}
public int id() {
return _id;
}
public double price() {
return _price;
}
}
And the following stream :
final Stream<Item> items = Stream.<Item>builder()
.add(new Item(1, 4))
.add(new Item(1, 6))
.add(new Item(1, 3))
.add(new Item(2, 5))
.add(new Item(2, 1))
.add(new Item(3, 5))
.build();
After the required operation, if the rule of deduplication is "with the highest price", the stream should only contains Item(1, 6), Item(2, 5) and Item(3, 5).
If I do this imperatively, I can consume my items while they have the same id, backing them up in a temporary collection, and deduplicate this collection when encountering an item with a different id.
If I use collect to first group the items by id, I will consume all the data at once before moving to the next operation, and I need to avoid that.

For most cases of that kind, a temporary storage, like a Map, is inevitable. After all, it’s the map’s efficient lookup algorithm that allows to identify the group each element belongs to. Also, it’s possible that the first group contains the first and the very last element of the source stream and the only way to find out whether this is the case, is iterating the entire source stream. This might not be true for your special case of pre-sorted data, but the API doesn’t provide a way to exploit this for a grouping operation. And it wouldn’t play nicely with parallel Stream support, if it existed.
But consider the groupingBy collector accepting a downstream Collector which allows you to reduce the groups to their final result in-place. If it is a true reduction, you can use, e.g. reducing as downstream collector. This allows you to collect the elements into a Map<Id, Reduced> rather than Map<Id, List<Elem>>, so you don’t collect into Lists that have to be reduced afterwards.
For any similar case, if you can describe the follow-up operation as a Collector, its processing will indeed start right when encountering the first element of a group. Note that there are other combining Collectors like mapping and collectingAndThen. Java 9 will also add filtering and flatMapping, so you can express a lot of typical Stream operations in form of a downstream collector. For convenience, this collector combines a mapping step with a follow-up reduction step.
Further processing of the groups can only be done after the full completion of the grouping, by accessing Map.values(). If the final result is supposed to be a Collection, it’s not necessary to stream over it again, as the existing collection operations are sufficient, e.g. you can use new ArrayList<>(map.values()) if you need a List rather than an unspecific Collection.
If your concern is that the operation should not be performed until the caller commences a terminal operation on the final Stream, you can use an operation like this:
public Stream<ResultType> stream() {
return StreamSupport.stream(() -> items.stream()
.collect(Collectors.groupingBy(classificationFunc,
Collectors.reducing(id, mappingFunc, reductionFunc)))
.values().spliterator(),
Spliterator.SIZED, false);
}

I haven't tested this, but using the StreamEx library, you should be able to collapse() adjacent elements like this:
items.collapse((a, b) -> a.id() == b.id(), (a, b) -> a.price() < b.price() ? b : a)

Rx Observables: emit additional item for each original item, reduce them to another type, consume

I am having problems doing the following using Couchbase Java client 2.2.2 and Rx Observables 1.0.15:
I have a list of strings which are document names
Along with each original document for a document name I would like to load another document (deduced from the original document name) so I would get a pair of documents. If any of those two documents do not exist, do not use this pair any more.
If the pair is valid (i.e. both documents exist) then use both documents to create a custom object from them
combine those transformed items into a list
What I have come up with so far looks really mean:
List<E> resultList = new ArrayList<>();
Observable
.from(originalDocumentNames)
.flatmap(key -> {
Observable firstDocument = bucket.async().get(key);
Observable secondDocument = bucket.async().get(getSecondKeyNameFrom(key));
return Observable.merge(firstDocument, secondDocument);
})
.reduce((jsonDocument1, jsonDocument2) -> {
if (jsonDocument1 == null || jsonDocument2 == null) {
return null;
}
resultList.add(createCustomObject(jsonDocument1, jsonDocument2);
return null;
})
.filter(Objects.nonNull)
.singleOrDefault(null)
.subscribe(new Subscriber<E>() {
public void onComplete() {
//use resultList in a callback function
}
});
This does not work. I do not know where, but I think I am using Observable.merge the wrong way.
Also I think I am approaching the whole problem the wrong way.
So the main questions it seems are:
how do I emit an additional item to an Observable stream?
how can I reduce two items into an item of another type? (reduce(T, T, T) does not allow that)
am I taking it on wrong?

You could use zip inside the flatmap. Zip will emit as many items as the Observable with the fewest items. So if one of the documents is missing, its sequence will be empty and zip will skip it.
Observable
.from(originalDocumentNames)
.flatmap(key -> {
//the stream of 0-1 original document
Observable firstDocument = bucket.async().get(key);
//the stream of 0-1 associated document
Observable secondDocument = bucket.async().get(getSecondKeyNameFrom(key));
//using zip and the createCustomObject method reference as a zip function to combine pairs of documents
return Observable.zip(firstDocument, secondDocument, this::createCustomObject);
})
.toList() //let RxJava aggregate into a List
.subscribe(
//the "callback" function, onNext will be called only once with toList
list -> doSomething(list),
//always try to define onError (best practice)
e -> processErrors(e)
);

There's several issue in this code :
side effect, the reduce operation is adding to a list outside the Observable chain, that's wrong. The reduce should either return the list or don't exists at all as Rx has a toList operation. Also because of the reduce operation that returns null the next operations have to handle that ; this is rather inelegant.
merge operation is wrong, you should instead zip in the flatmap and build the pair/aggregate.
Optional point : the flatmap operation does not handle if either get operation will return multiple items (maybe that's de facto the case with couchbase)
Note I don't have an IDE so no code for now. But in my point replacing merge by zip and removing reduce certainly should help.