Path: csiph.com!1.us.feeder.erje.net!3.us.feeder.erje.net!2.eu.feeder.erje.net!feeder.erje.net!news.uzoreto.com!newsreader4.netcologne.de!news.netcologne.de!.POSTED.2a0a-a547-a9a3-0-6065-318e-99ea-26de.ipv6dyn.netcologne.de!not-for-mail
From: Patrick Roemer <sangamon@netcologne.de>
Newsgroups: de.comp.lang.java
Subject: Re: Brauche Hilfe bei "Funktionale Programmierung "
Date: Mon, 21 Nov 2022 10:10:53 +0100
Organization: news.netcologne.de
Distribution: world
Message-ID: <tlffat$3ltdo$1@newsreader4.netcologne.de>
References: <tlb95p$1k03$1@gwaiyur.mb-net.net> <tlbf81$4v0f$1@yggdrasil.dn.cgarbs.de> <tlbo6p$2f4v$1@gwaiyur.mb-net.net>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Mon, 21 Nov 2022 09:10:53 -0000 (UTC)
Injection-Info: newsreader4.netcologne.de; posting-host="2a0a-a547-a9a3-0-6065-318e-99ea-26de.ipv6dyn.netcologne.de:2a0a:a547:a9a3:0:6065:318e:99ea:26de"; logging-data="3863992"; mail-complaints-to="abuse@netcologne.de"
User-Agent: Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.8.1.24) Gecko/20100411 Thunderbird/2.0.0.24 Mnenhy/0.7.6.0
Content-Language: en-US
In-Reply-To: <tlbo6p$2f4v$1@gwaiyur.mb-net.net>
Xref: csiph.com de.comp.lang.java:13419

Responding to Ralf Schneider:
> public List<ZahlenPaar> mischeZahlenListen(List<BigInteger> listeInnen,
> List<BigInteger> listeAussen){
> 
> // Darin eine Funktion zur Erstellung eins Objektes:
> BiFunction<BigInteger, BigInteger, ZahlenPaar> erstelleObjekt = (o,i) ->
> { ZahlenPaar zp = new ZahlenPaar(i, o);
>                          	return zp;
>                          	};
> 
> List<ZahlenPaar> gemischtePaare = listeAussen.stream()
>                                 	        .map(first -> {
> ZahlenPaar attribute = listeInnen.stream()
>                              .filter(second -> second != BigInteger.ZERO)
>                              .mapToObj(second -> { ZahlenPaar z =
> erstelleObjekt.apply(first, second);
>                        	        return z;
>      	                       });}).collect(Collectors.toList());
> 
> return gemischtePaare;
> }
> 
> Ich will zwei Listen (List<BigInteger> ) in einer geschachtelten Schleife
> so miteinander kombinieren, dass alle Elemente der einen Liste mit allen
> Elementen der anderen Liste paarig in je ein Objekt des Typs
> List<ZahlenPaar> umgewandelt werden.(1,2,3 und 4,5,6 sollen werden 1;4,
> 1;5, 1;6, 2;4 usw. bis zum neunten.)

Disclaimer: Mein Java ist etwas angestaubt, kann durchaus sein, dass es 
besser geht...

Wenn Du verschachtelt über zwei Streams #map() aufrufst, erhältst Du 
auch ein verschachteltes Stream<Stream<...>>. Du wirst den Kombinator 
#flatMap() benötigen.

Vergleiche die Signaturen:

<R> Stream<R> map(Function<? super T, ? extends R> mapper);
<R> Stream<R> flatMap(
   Function<? super T, ? extends Stream<? extends R>> mapper
);

https://www.baeldung.com/java-difference-map-and-flatmap

import java.math.*;
import java.util.*;
import java.util.stream.*;

static class Pair<A, B> {
   // ...
}

private static <A, B> List<Pair<A, B>> combinations(
     List<A> as, List<B> bs
) {
   return
     as.stream().flatMap(a ->
       bs.stream().map(b ->
         new Pair<A, B>(a, b)
       )
     )
     .collect(Collectors.toList());
}

List<BigInteger> as =
   Arrays.asList(1, 2, 3)
     .stream()
     .map(BigInteger::valueOf)
     .collect(Collectors.toList());
List<BigInteger> bs =
   Arrays.asList(4, 5, 6)
     .stream()
     .map(BigInteger::valueOf)
     .collect(Collectors.toList());
System.out.println(combinations(as, bs));
// [(1, 4), (1, 5), (1, 6), (2, 4), ...]

Mit #mapMulti() kann man zum selben Ergebnis kommen, da sehe ich aber 
konzeptuell überhaupt keinen Vorteil - #flatMap() ist generischer.

https://www.baeldung.com/java-mapmulti

Wenn Du eh schon Java machst und funktionale Aspekte einbringen willst, 
fein. Wenn Du (auf der JVM) funktionale Programmierung lernen möchtest, 
könnte Scala eine bessere Wahl sein. Nur zum Vergleich mal Scala-Versionen:

def combinations[A, B](as: List[A], bs: List[B]): List[(A, B)] =
   as.flatMap(a => bs.map((a, _)))

def combinations[A, B](as: List[A], bs: List[B]): List[(A, B)] =
   for { a <- as ; b <- bs } yield (a, b)