BiPredicate in einer forEach Methode

[ocsme]

Hallo zusammen,

ich würde gerne einen BiPredicate matchen und in der forEach Methode dann nutzen.
Das ganze sieht so aus:

BiPredicate<Kunde, Integer> geborenNach = (k,j) -> k.geb >= j;

Die Klasse Kunde speichert einfach nur das Geburtsdatum etc.
Nun kann ich dieses Predikät ja so in einer ForEach Schleife nutzen:

        for(Kunde k : kundenList)
            if(geborenNach.test(k, 1950))
                System.out.println(k);

Was ich nun möchte ist meine kundenList eben mit kundenList.stream().allMatch(geborenNach(k,1959).forEach(System.out:😛rintln).
Doch die allMatch Methode erwartet ja ein Predicate und kein BiPredicate. Derzeit habe ich keine Methode gefunden :-(
Muss ich das BiPredicate umschreiben zu einem normalen Predicate? Geht das überhaupt so leicht?

 

[httpdigest]

allMatch ist nicht die Methode, die du möchtest. allMatch liefert insgesamt ein boolean zurück, der angibt, ob ALLE Elemente im Stream ein Prädikat erfüllen. Du willst filter().
Desweiteren musst du einfach nur ein Predicate<Kunde> erzeugen, z.B. durch Anwendung von geborenNach.test(k, j), wobei j ein konkreter Parameter ist und k ungebunden ist. Java hat leider leider keine partielle Auswertung, somit brauchst du z.B. eine weitere Lambda Expression, die statisch den Typ Predicate<Kunde> hat und z.B. als Wert eine Auswertung von geborenNach.test(k, j) mit einem konkreten j ist, aber dem k aus deiner neuen Lambda-Expression, also z.B. so:

static BiPredicate<Kunde, Integer> geborenNach = (k, j) -> k.geb >= j;
static Predicate<Kunde> geborenNach(int j) {
    return k -> geborenNach.test(k, j);
}

// in einer anderen Methode:
kundenList.stream().filter(geborenNach(1959)).forEach(System.out::println);

 

[ocsme]

Vielen Dank für die schnelle Antwort 🙂
Das ganze leuchtet mir nun ein. Als ich gerade eben den Post verfasst habe, ist mir auch kurz drauf eingefallen das allMatch eine Terminale Operation ist.
Da muss ich weiter am Ball bleiben 🙂 Nochmals Danke

 

[handshake45]

Ich hätte es so gemacht:

import java.util.ArrayList;
import java.util.List;
import java.util.function.BiFunction;
import java.util.stream.Stream;

public class Kunde {
	public static BiFunction<List<Kunde>, Integer, Stream<Kunde>> filteredStream = (kunden, jahr) -> kunden.stream().filter(k -> k.geb >= jahr);
	private int geb;
	Kunde(int geb) {
		this.geb = geb;
	}
	public static void main(String[] args) {
		ArrayList<Kunde> kunden = new ArrayList<Kunde>();
		Kunde kunde1 = new Kunde(1949);
		Kunde kunde2 = new Kunde(1951);
		Kunde kunde3 = new Kunde(1949);
		kunden.add(kunde1);
		kunden.add(kunde2);
		kunden.add(kunde3);
		filteredStream.apply(kunden, 1950).forEach(System.out::println);
		System.out.println(kunde2);
	}
}

 

[ocsme]

Danke @handshake45 das habe ich noch gar nicht gesehen so =)
Ich versuche mich gerade in die Lambda Thematik deutlich besser einzuarbeiten 🙂 Mein Problem ist eben auch das ich viele Methoden nicht kenne weil ich von Anfang an die Methoden immer selbst geschrieben hab um zu verstehen wie es geht und ob das korrekt ist was ich mache :-D Vielleicht eine Doofe Idee aber naja =D

 

[httpdigest]

Vielleicht wäre für das grundsätzliche Verständnis von bzw. Denkweise bei funktionaler Programmierung für dich auch die Sprache Haskell interessant. Dein Beispiel liesse sich z.B. so umsetzen:

data Kunde = Kunde { geb :: Int } deriving (Show)
geborenNach = (. geb) . (<=)
alleGeborenNach = filter . geborenNach
nach1990Geboren = alleGeborenNach 1990
main = do
  let kundenListe = [Kunde{geb=1989},
                     Kunde{geb=1990},
                     Kunde{geb=1994}]
  putStrLn $ show (nach1990Geboren kundenListe)

Da hast du z.B. ganz simple Funktionskomposition (.), partielle Auswertung, in die Sprache eingebaute Listenstrukturen und Tupel. Vielleicht macht es für dich Sinn, das Ganze so rum zu lernen und dann das Gelernte in Java anzuwenden.
Warum glaube ich das: Weil Javas objektorientiertes und nominale Typsystem und das "Draufstülpen" von funktionalen Aspekten es Neulingen eher schwer macht, funktional zu denken, weil man mehr damit beschäftigt ist, die richtigen Interfaces/Klassen zu finden und per Lambda-Adapter miteinander zu verbinden, statt die implementierte Funktion und den "Flow" der Informationen dadurch zu sehen.

 

[ocsme]

weil man mehr damit beschäftigt ist, die richtigen Interfaces/Klassen zu finden und per Lambda-Adapter

So geht es mir derzeit. Ich schaue dann über Eclipse immer in die Klassen rein. Oft schreibe ich die ganzen Lambdas dann auch erst so:

        BiPredicate<Kunde, Integer> test = new BiPredicate<Kunde, Integer>() {

            @Override
            public boolean test(Kunde t, Integer u) {
                // TODO Auto-generated method stub
                return t.geb >= u;
            }
            
        };

Ich weiß auch das ist nicht im Sinne des Erfinders doch wie du schon festgestellt hast finde ich es am Anfang echt schwer so umzudenken :-(
Derzeit stehe ich auch wieder vor einem kleinen Problem. Da ich keine Lambda Aufgaben habe sondern mir einfach so welche Ausdenke, hatte ich mir vorgestellt ich erstelle eine List<String> und entferne in dieser Liste dann alle kleinen Buchstaben oder große Buchstaben oder Sonderzeichen. Einfach dann eben nur etwas rum spielen mit dem ganzen 🙃
Doch ich bekomme es nicht hin =(

List<String> sl = new ArrayList<>();
        sl.add("DAS");
        sl.add("ist");
        sl.add("ein");
        sl.add("Test");
        sl.add("5§$");

Jetzt wollte ich erst einmal alle kleinen Buchstaben löschen lassen.
also dachte ich sl.replaceAll(); doch da ich auch die ganzen Methoden so nicht im Kopf habe :-( Ist es so für mich unmöglich. Deswegen fahre ich wieder den Ansatz:

        sl.replaceAll(new UnaryOperator<String>() {

            @Override
            public String apply(String t) {
                String erg = "";
                for(int i = 0; i < t.length(); i++)
                    if(Character.isLowerCase(t.charAt(i)))
                        erg += t.charAt(i);
                return erg;
            }
            
        });

An der Stelle liegt das Problem eher an der Klasse String würde ich sagen :-( Regex wäre ich auch froh über ein gutes Tutorial. Da hab ich mich mal eingelesen doch irgendwie wollte das überhaupt nicht klappen :-(

 

[Flown]

Regex ist relativ simpel, wenn man weiß was man genau (nicht) haben möchte. In deinem Fall sind es nur Kleinbuchstaben, alle anderen sollen mit einem Leerstring ersetzt werden:
Das äquivalent in Java (Character::isLowerCase) ist in JavaRegex: \p{javaLowerCase}
Und somit könnte dein ganzer Code dann so aussehen:

List<String> sl = List.of("DAS" , "ist" , "ein" , "Test" , "ä5§$");
sl.stream()
    .map(t -> t.replaceAll("[^\\p{javaLowerCase}]", ""))
    .filter(t -> !t.isEmpty())
    .forEach(System.out::println);

 

[ocsme]

Das muss ich mir dringend anschauen 🙂
Ich weiß nämlich derzeit auch nicht wie es ohne Regex gehen soll! Außer man codet es dann oben aus und gibt in map dann den String zurück geht ja auch doch mit Regex geht es ja viel schöner 🙂

 

[handshake45]

Mein Problem ist eben auch das ich viele Methoden nicht kenne weil ich von Anfang an die Methoden immer selbst geschrieben hab um zu verstehen wie es geht und ob das korrekt ist was ich mache :-D Vielleicht eine Doofe Idee aber naja

Nein keine doofe Idee... Das mache ich bis heute noch so - und viele der Youngsters können es heute einfach nicht mehr anders.

Bleib am Ball. 🙂

 

[ocsme]

Bleib am Ball.

Danke 🙂 nur ist es so eben doppelter Aufwand ;-) Man muss die Sachen verstehen und später so oder so die ganzen Methoden aus den Klassen lernen! Sonst sieht es später übel aus 🙃

Hat noch jemand eine andere Idee mit der String Liste ohne Regex? Ich bin da schon die ganze Zeit am knobeln doch nicht wirklich produktives =(