How to rewrite it using stream api - java

I don't know all capabilities of Stream API.
My task is: I have a list of strings with urls and I have another list of my custom objects with two methods
String videoFromUrl(String url);
boolean support(String url);
I should to choose an url from first list which will be supported by one instance of second list then return converted url
My code is:
#Override
protected String videoSourceFromDocument(final Document document) {
final List<String> hrefs = ...;
for (final String href : hrefs) {
final Optional<VideoDownloader> videoDownloader = this.videoDownloaders/*this is my second list*/
.stream()
.filter(dwnldr->dwnldr.support(href))
.findFirst();
if(videoDownloader.isPresent()){
return videoDownloader.get().videoFromUrl(href);
}
}
this.logger().warn("Url {} doesn't has video source",document.baseUri());
throw new IllegalArgumentException();
}
Is it better way to rewrite it using Stream API?


When you need two inner loops to do something in an imperative way, the solution to do the same thing using streams is usually to use a flatMap:
protected String videoSourceFromDocument(final Document document) {
final List<String> hrefs = ...;
return hrefs.stream()
.flatMap(href -> this.videoDownloaders.stream()
.filter(d -> d.support(href))
.map(d -> d.videoFromUrl(href)))
.findFirst()
.orElseThrow(() -> {
this.logger().warn("Url {} doesn't has video source", document.baseUri());
return new IllegalArgumentException();
});
}
I would remove the log, though, and put the informative message in the IllegalArgumentException. Or simply return an Optional<String>, so that the caller can decide what to do when there is no video source.


You can replace the for loop with a Stream pipeline using some Optional methods:
return hrefs.stream() // Stream<String>
.map(href -> this.videoDownloaders
.stream() // Stream<VideoDownloader>
.filter(dwnldr->dwnldr.support(href))
.findFirst() // Optional<VideoDownloader>
.map(dwnldr -> dwnldr.videoFromUrl(href))) // Stream<Optional<String>>
.filter(Optional::isPresent) // keep only the non-empty Optionals
.findFirst() // Optional<Optional<String>>
.orElseThrow(IllegalArgumentException::new) // Optional<String>
.get(); // String

Related

How to filter based on list returned by map param using Java 8 streams

I'm trying to use Java stream to filter some values based on certain conditions. I am able to achieve the same using traditional for loops and a little bit of streams, but I want to rewrite the same logic fully in streams.
Original code:
public List <String> getProductNames(Hub hub, String requestedGroup) {
List <SupportedProduct> configuredProducts = repo.getSupportedProducts(hub);
List <String> productNames = new ArrayList <> ();
for (SupportedProduct supportedProduct: configuredProducts) {
List < String > categoryNameList = new ArrayList <> ();
String activeCategoryName = supportedProduct.getCategoryDetails().getActiveCategoryName();
if (activeCategoryName == null) {
Optional.ofNullable(supportedProduct.getCategoryDetails().getCategories())
.orElse(Collections.emptyList())
.forEach(category - > categoryNameList.add(category.getName()));
} else {
categoryNameList.add(activeCategoryName);
}
for (String catName: categoryNameList) {
Division division = divisionRepo.getDivisionByCatName(catName);
if (division != null && division.getGroup() == requestedGroup) {
productNames.add(supportedProduct.getProductName());
}
}
}
return productNames;
}
My try:
return Optional.ofNullable(configuredProducts).orElse(Collections.emptyList()).stream()
.map(supportedProduct -> {
List<String> categoryNameList = new ArrayList<>();
String activeCategoryName = supportedProduct.getCategoryDetails().getActiveCategoryName();
if (activeCategoryName == null) {
Optional.ofNullable(supportedProduct.getCategoryDetails().getCategories())
.orElse(Collections.emptyList())
.forEach(category -> categoryNameList.add(category.getName()));
} else {
categoryNameList.add(activeCategoryName);
}
return categoryNameList;
})
.filter(catName ->{
Division division = divisionRepo.getDivisionByCatName(catName);
return division != null && division.getGroup() == requestedGroup;
})........
But I'm lost beyond this.
Please help me to write the same using streams.
EDIT: Added IDEOne for testing - Link

The logic inside is quite complicated, however, try this out:
public List <String> getProductNames(Hub hub, String requestedGroup) {
List<SupportedProduct> configuredProducts = repo.getSupportedProducts(hub);
// extract pairs:
// key=SupportedProduct::getProductName
// values=List with one activeCategoryName OR names of all the categories
Map<String, List<String>> namedActiveCategoryNamesMap = configuredProducts.stream()
.collect(Collectors.toMap(
SupportedProduct::getProductName,
p -> Optional.ofNullable(p.getCategoryDetails().getActiveCategoryName())
.map(Collections::singletonList)
.orElse(Optional.ofNullable(p.getCategoryDetails().getCategories())
.stream()
.flatMap(Collection::stream)
.map(Category::getName)
.collect(Collectors.toList()))));
// look-up based on the categories' names, group equality comparison and returning a List
return namedActiveCategoryNamesMap.entrySet().stream()
.filter(entry -> entry.getValue().stream()
.map(catName -> divisionRepo.getDivisionByCatName(catName))
.filter(Objects::nonNull)
.map(Division::getGroup)
.anyMatch(requestedGroup::equals))
.map(Map.Entry::getKey)
.collect(Collectors.toList());
}
I recommend splitting into separate methods for sake of readability (the best way to go).
The verbose logics of Optional chains including two orElse calls can be surely simplified, however, it gives you the idea.
You can perform within one Stream using Collectors.collectingAndThen. In that case, I'd extract the Function finisher elsewhere, example:
public List<String> getProductNames(Hub hub, String requestedGroup) {
return repo.getSupportedProducts(hub).stream()
.collect(Collectors.collectingAndThen(
Collectors.toMap(
SupportedProduct::getProductName,
categoryNamesFunction()),
productNamesFunction(requestedGroup)));
}
private Function<Map<String, List<String>>, List<String>> productNamesFunction(String requestedGroup) {
return map -> map.entrySet().stream()
.filter(entry -> entry.getValue().stream()
.map(divisionRepo::getDivisionByCatName)
.filter(Objects::nonNull)
.map(Division::getGroup)
.anyMatch(requestedGroup::equals))
.map(Map.Entry::getKey)
.collect(Collectors.toList());
}
private Function<SupportedProduct, List<String>> categoryNamesFunction() {
return p -> Optional.ofNullable(p.getCategoryDetails().getActiveCategoryName())
.map(Collections::singletonList)
.orElse(Optional.ofNullable(p.getCategoryDetails().getCategories())
.stream()
.flatMap(Collection::stream)
.map(Category::getName)
.collect(Collectors.toList()));
}

How to store intermediate state in a Java stream processing

I have the following Java loop:
for (final Long orderNumber : availableOrderIds) {
final List<ReservationDetailResponse> reservations = tryToReserve(orderNumber);
if (successful(reservations)) {
return withReservationIdFrom(reservations);
}
}
And methods:
private boolean successful(final List<ReservationDetailResponse> reservations) {
return !reservations.isEmpty();
}
private Long withReservationIdFrom(final List<ReservationDetailResponse> reservations) {
return reservations.get(0).getReservationId();
}
How do I convert it into a stream processing?
Thanks for any help!

Using map for transformation, filter for conditions and findFirst you can do somethign like:
return availableOrderIds.stream()
.map(this::tryToReserve)
.filter(this::successful)
.findFirst()
.map(this::withReservationIdFrom)
.orElse(0L); // assumed as default value
Additionally, provided the utilities, you can include them within the operations as well:
return availableOrderIds.stream()
.map(this::tryToReserve)
.filter(res -> !res.isEmpty())
.findFirst()
.map(res -> res.get(0).getReservationId())
.orElse(0L);

Something along the lines of the following:
availableOrderIds.stream()
.map(orderNumber -> tryToReserve(orderNumber))
.filter(reservation -> successful(reservation))
.map(reservations -> withReservationIdFrom(reservations))
.findFirst()
.get();

Use same variable in filter() and map() of a Java 8 stream

To improve performance I want to use the same variable in both filter() and map() of a Java 8 stream.
Example-
list.stream()
.filter(var -> getAnotherObject(var).isPresent())
.map(var -> getAnotherObject(var).get())
.collect(Collectors.toList())
The called method getAnotherObject() looks like-
private Optional<String> getAnotherObject(String var)
In the above scenario I have to call the method getAnotherObject() twice.If I go with a regular for loop then I have to call the method getAnotherObject() only once.
List<String> resultList = new ArrayList<>();
for(String var : list) {
Optional<String> optionalAnotherObject = getAnotherObject(var);
if(optionalAnotherObject.isPresent()) {
String anotherObject = optionalAnotherObject.get();
resultList.add(anotherObject)
}
}
Even with stream I can put all my code in map()-
list.stream()
.map(var -> {
Optional<String> anotherObjectOptional = getAnotherObject(var);
if(anotherObjectOptional.isPresent()) {
return anotherObjectOptional.get();
}
return null;
})
.filter(Objects::nonNull)
.collect(Collectors.toList());
But I believe there must be an elegant way using filter().

You can create a stream like this
list.stream()
.map(YourClass::getAnotherObject)
.filter(Optional::isPresent)
.map(Optional::get)
.collect(Collectors.toList());
YourClass refer to the name of the class where getAnotherObject method is defined

You can use flatMap. Usually this is used to flatten stuff, but here you can
map the element to that element if the optional has a value
map the element to an empty stream if the optional has no value
Like this:
stream
.map(x -> getAnotherObject(x))
.flatMap(x -> x.map(Stream::of).orElse(Stream.of())))

Java 8 list processing - add elements conditionally

I have the following piece of code:
List<Object> list = new ArrayList<>();
list.addAll(method1());
if(list.isEmpty()) { list.addAll(method2()); }
if(list.isEmpty()) { list.addAll(method3()); }
if(list.isEmpty()) { list.addAll(method4()); }
if(list.isEmpty()) { list.addAll(method5()); }
if(list.isEmpty()) { list.addAll(method6()); }
return list;
Is there a nice way to add elements conditionally, maybe using stream operations? I would like to add elements from method2 only if the list is empty otherwise return and so on.
Edit: It's worth to mention that the methods contain heavy logic so need to be prevented from execution.

You could try to check the return value of addAll. It will return true whenever the list has been modified, so try this:
List<Object> list = new ArrayList<>();
// ret unused, otherwise it doesn't compile
boolean ret = list.addAll(method1())
|| list.addAll(method2())
|| list.addAll(method3())
|| list.addAll(method4())
|| list.addAll(method5())
|| list.addAll(method6());
return list;
Because of lazy evaluation, the first addAll operation that added at least one element will prevent the rest from bein called. I like the fact that "||" expresses the intent quite well.

I would simply use a stream of suppliers and filter on List.isEmpty:
Stream.<Supplier<List<Object>>>of(() -> method1(),
() -> method2(),
() -> method3(),
() -> method4(),
() -> method5(),
() -> method6())
.map(Supplier<List<Object>>::get)
.filter(l -> !l.isEmpty())
.findFirst()
.ifPresent(list::addAll);
return list;
findFirst() will prevent unnecessary calls to methodN() when the first non-empty list is returned by one of the methods.
EDIT:
As remarked in comments below, if your list object is not initialized with anything else, then it makes sense to just return the result of the stream directly:
return Stream.<Supplier<List<Object>>>of(() -> method1(),
() -> method2(),
() -> method3(),
() -> method4(),
() -> method5(),
() -> method6())
.map(Supplier<List<Object>>::get)
.filter(l -> !l.isEmpty())
.findFirst()
.orElseGet(ArrayList::new);

A way of doing it without repeating yourself is to extract a method doing it for you:
private void addIfEmpty(List<Object> targetList, Supplier<Collection<?>> supplier) {
if (targetList.isEmpty()) {
targetList.addAll(supplier.get());
}
}
And then
List<Object> list = new ArrayList<>();
addIfEmpty(list, this::method1);
addIfEmpty(list, this::method2);
addIfEmpty(list, this::method3);
addIfEmpty(list, this::method4);
addIfEmpty(list, this::method5);
addIfEmpty(list, this::method6);
return list;
Or even use a for loop:
List<Supplier<Collection<?>>> suppliers = Arrays.asList(this::method1, this::method2, ...);
List<Object> list = new ArrayList<>();
suppliers.forEach(supplier -> this.addIfEmpty(list, supplier));
Now DRY is not the most important aspect. If you think your original code is easier to read and understand, then keep it like that.

You could make your code nicer by creating the method
public void addAllIfEmpty(List<Object> list, Supplier<List<Object>> method){
if(list.isEmpty()){
list.addAll(method.get());
}
}
Then you can use it like this (I assumed your methods are not static methods, if they are you need to reference them using ClassName::method1)
List<Object> list = new ArrayList<>();
list.addAll(method1());
addAllIfEmpty(list, this::method2);
addAllIfEmpty(list, this::method3);
addAllIfEmpty(list, this::method4);
addAllIfEmpty(list, this::method5);
addAllIfEmpty(list, this::method6);
return list;
If you really want to use a Stream, you could do this
Stream.<Supplier<List<Object>>>of(this::method1, this::method2, this::method3, this::method4, this::method5, this::method6)
.collect(ArrayList::new, this::addAllIfEmpty, ArrayList::addAll);
IMO it makes it more complicated, depending on how your methods are referenced, it might be better to use a loop

You could create a method as such:
public static List<Object> lazyVersion(Supplier<List<Object>>... suppliers){
return Arrays.stream(suppliers)
.map(Supplier::get)
.filter(s -> !s.isEmpty()) // or .filter(Predicate.not(List::isEmpty)) as of JDK11
.findFirst()
.orElseGet(Collections::emptyList);
}
and then call it as follows:
lazyVersion(() -> method1(),
() -> method2(),
() -> method3(),
() -> method4(),
() -> method5(),
() -> method6());
method name for illustration purposes only.

How to return Optional String using Java 8 streams

This code should return the Optional String when given siteUrl contains key from the predefined list of pairs (or Optional.empty() otherwise).
Is there a better way than using new Pair(null, null) here? Or maybe change the whole expression?
static Optional<String> get(String siteUrl) {
return Optional.ofNullable(URL_TO_ENVIRONMENT
.stream()
.filter(p -> siteUrl.contains(p.getKey()))
.findFirst().orElse(new Pair(null, null)).getValue());
}
private static final List<Pair> URL_TO_ENVIRONMENT = buildList();
private static List<Pair> buildList() {
return Arrays.asList(
new Pair("aaa.mysite.com", "aaa_something"),
new Pair("bbb.mysite.com", "bbb_something"),
new Pair("ccc.mysite.com", "ccc_comething"));
}

return URL_TO_ENVIRONMENT.stream()
.filter(p->siteUrl.contains(p.getKey()))
.map(Pair::getvalue)
.findFirst();
Do you specifically need the first match? if you just want any match, use findAny instead of findFirst.

Categories

Resources