Porting Scala For-Comprehension usage examples in pure Java 8+ examples ( at least some interesting examples )

ForComp_ScalaPorting.java

import java.util.List;
import java.util.Optional;
import java.util.function.Function;
import java.util.stream.Stream;
import static java.util.stream.Collectors.toList;

/**
 * 
 * @author Stefano fago
 * 
 * Here are not used Records to be compatible with Java 8+
 * Using Records and .toList() with newer Java for smaller code! ;-) 
 * Inside every example the related Scala code.
 *
 */
public class ForComp_ScalaPorting {


	public static void main(String[] args) {
		
		for_comprehension_with_filtering();

		for_comprehension_inner_elements_with_filtering();
		
		for_comprehension_twoOptionalsSameType();
		
		for_comprehension_twoOptionalsSameType_with_filtering("a");
		
		for_comprehension_twoOptionalsMixed();
		
		for_comprehension_moreOptionalsMixed();
		
		for_comprehension_listOfOptionals();
		
	}

	// ========================================================================
	//
	//
	//
	// ========================================================================



	private static void for_comprehension_with_filtering() {
		
		class Book{
			String title;
			String author;
			Book(String title, String author){}
		}
		
		var books = List.of(new Book("Title1","Auth1"),new Book("Title2","Auth2"));
		
		/*
		 
     for {
			  book <- books
			  if book.author startsWith "bob" 
			} yield book.title
      
		 */
		
		Stream<String> titlesFromBob = 
		
		books.stream()
		     .filter(
		        book-> book.author.startsWith("bob"))
			   .map(
			        book->book.title);
		
	}
	
	
	private static void for_comprehension_inner_elements_with_filtering() {
		
		class Book{
			String title;
			List<String> authors;
			Book(String title, List<String> authors){}
		}
		
		var books = List.of(new Book("Title1",List.of("Auth1","Auth2")),
				            new Book("Title2",List.of("Auth3")));
		
		/*
    
		 for {
			  book <- books
			  author <- book.authors 
			  if author startsWith "bob" 
			} yield book.title
		
    */
		
		Stream<String> titlesFromBookWithAlsoBob = 
		books.stream()
		   .flatMap(
		      book->book.authors.stream()
		            .filter(
			        author->author.startsWith("bob"))
				    .map(
				       author->book.title));
	}
	
	
	
	private static void for_comprehension_twoOptionalsSameType() {
		 
		/*		  
		  for {
			     a <- optA
			     b <- optB
			} yield (a,b)

		 */

		class Result {
			Result(String a, String b) {
			}
		}

		var optA = Optional.ofNullable("VAL_1");
		var optB = Optional.ofNullable("VAL_2");

		Optional<Result> result = optA.flatMap(a -> optB.map(b -> new Result(a, b)));

	}

	private static void for_comprehension_twoOptionalsSameType_with_filtering(String prefix) {

		/*
		 
		 for {
			  a <- optA
			  if(a startsWith "a")
			  b <- optB
			} yield (a,b)
          
		 */

		class Result {
			Result(String a, String b) {
			}
		}

		var optA = Optional.ofNullable("VAL_1");
		var optB = Optional.ofNullable("VAL_2");

		Optional<Result> result = 
		    optA.filter(
		           a->a.startsWith(prefix))
			     .flatMap(
			        a->optB.map(b->new Result(a,b)));
		
	}
	
	
	private static void for_comprehension_twoOptionalsMixed() {

		class Result {
			Result(String a, int b) {
			}
		}
		var optA = Optional.ofNullable("VAL_1");
		var optB = Optional.ofNullable(1000);

		Optional<Result> result = optA.flatMap(a -> optB.map(b -> new Result(a, b)));
	}

	
	private static void for_comprehension_moreOptionalsMixed() {

		class Result {
			Result(String a, String b, int c) {
			}
		}

		var optA = Optional.ofNullable("VAL_1");
		var optB = Optional.ofNullable("VAL_2");
		var optC = Optional.ofNullable(1000);

		Optional<Result> result = 
		  optA.flatMap(
		      a -> optB.flatMap(
		           b -> optC.map(
			      c -> new Result(a, b, c))));

	}
	
	
	private static void for_comprehension_listOfOptionals() {

		List<Optional<Integer>> listOfMaybeNumbers = 
				                 List.of( Optional.of(1),
				                          Optional.empty(),
				                          Optional.of(2),
				                          Optional.of(3),
				                          Optional.empty());
       /*
        
        for {
			  optNumber <- optNumbers
			  value <- optNumber
			} yield value +1
			
        */

	 List<Integer> filteredNumbers = 
	     listOfMaybeNumbers.stream()
	         .flatMap(
		     maybeNumber->maybeNumber
		        .map(
			    value->value+1).stream())
			               .collect(toList());	 
	}

}//END