Frage zu Java Streams min / max

[8u3631984]

Ich habe eine Frage zur min und max Funktion in Java Streams :
Nehmen wir einmal an ich habe eine Liste mit Integers :

        List<Integer> numbers = new ArrayList<>();
        numbers.add(31);
        numbers.add(35);
        numbers.add(32);
        numbers.add(41);
        numbers.add(45);
        numbers.add(42);
        numbers.add(21);
        numbers.add(25);
        numbers.add(22);
        numbers.add(11);
        numbers.add(15);

Wenn ich nun die min oder max Funktion aufrufe, benötige ich einen Comperator :

  numbers.stream().min(Comparator.naturalOrder()).ifPresent(System.out::println);

MIr ist der Vorteil hier nicht ganz klar :
IOch könnte die Liste ja auch normnal sorieren und dann das erste (min) bzw (letzte) Element zurücklioefern.

Noch eine Frage ohne es getestet zu haben :
Wenn ich die Liste umgekehrt sortiere (also das größte Element zuerst) und dann min / max aufrufe, bekomme ich dann einen anderen Wert als mit der natürlichen Ordnung ?

 

[Robert Zenz]

MIr ist der Vorteil hier nicht ganz klar :

Nur so als Anmerkung, ideal waere es die Liste gar nicht zu sortieren, sondern "einfach" das kleinste Element zu finden.

 

[LimDul]

MIr ist der Vorteil hier nicht ganz klar :
IOch könnte die Liste ja auch normnal sorieren und dann das erste (min) bzw (letzte) Element zurücklioefern.

Die Vorteile sind:

• Kürzer
• Lesbarer

Vor allem das lesbarer finde ich wichtig. So nimmt man beim lesen des Source Codes direkt bewusst war, dass hier das größte bzw. kleinste Element gesucht wird. Bei einer Sortierung und dann findFirst/findLast ist das nicht mehr direkt offensichtlich, sondern man muss da die Transferleistung erbringen, dass man sieht "Sortierung + erstes Element = kleinstes"

Hinzu kommt, dass je nach Implementierung min/max schneller sein kann. Min bzw. Max kann ich in O(n) implementieren, eine Sortierung braucht O(n*log n)

 

[Flown]

Wenn ich die Liste umgekehrt sortiere (also das größte Element zuerst) und dann min / max aufrufe, bekomme ich dann einen anderen Wert als mit der natürlichen Ordnung ?

Wenn du den Comparator umdrehst, dann ist natürlich das größte Element in der natürlichen Ordnung das Kleinste umgekehrt.

 

[Oneixee5]

Den Ausdruck:

numbers.stream().min(Comparator.naturalOrder()).ifPresent(System.out::println);

kann man auch ersetzen durch:

List.of(1, 2, 34, 5, -1).stream().reduce(Math::min).ifPresent(System.out::println);

Dann benötigt keinen Comparator. Es ist aber notwendig irgendwie die Listenelemente zu vergleichen. Man wählt eben, die für den Programmierer, sprechendste Variante.

 

[mihe7]

MIr ist der Vorteil hier nicht ganz klar :

Mir ist die Frage nicht ganz klar: von welchem Vorteil sprichst Du? Vom Stream oder davon, einen Comparator zu verwenden?

Wenn ich die Liste umgekehrt sortiere (also das größte Element zuerst) und dann min / max aufrufe, bekomme ich dann einen anderen Wert als mit der natürlichen Ordnung ?

Jein. Der Comparator definiert eine Ordnung und entsprechend dieser Ordnung gibt es in einer endlichen Menge ein kleinstes und ein größtes Element - es kann aber je nach Implementierung und Daten auch mehrere kleinste/größte Elemente geben.

Nehmen wir mal an, Du hast Personen und die haben ein Alter. Es kann aber natürlich mehrere Personen mit dem gleichen Alter geben. Ein Comparator, der die Ordnung der Personen nur über das Alter definiert, führt also daztu, dass mehrere Personen die kleinsten Elemente darstellen. Beim Finden des Minimums kann dann die Reihenfolge ausschlaggebend sein, in der die Elemente durchsucht werden (theoretisch kann auch zufällig ein Element aus der Menge der "kleinsten Personen" gewählt werden).

Existiert aber tatsächlich nur ein einziges kleinstes Element, dann ist die Reihenfolge, in der die Elemente durchsucht werden völlig egal.

public Optional<Person> juengste(List<Person> personen) {
    if (personen.isEmpty()) return Optional.empty(); 

    Person juengsteBisher = personen.get(0);
    for (int i = 1; i < personen.size(); i++) {
        Person person = personen.get(i);
        if (alterComparator.compare(person, juengsteBisher) < 0) {
            juengsteBisher = person;
        }
    }

    return Optional.of(juengsteBisher);
}

Bei dieser Implementierung würde die jüngste Person zurückgegeben, die vor allen anderen gleichaltrigen Personen in der Liste steht. Ersetzt Du die if-Bedingung < 0 durch <= 0, dann würdest Du die jüngste Person erhalten, die nach allen anderen gleichaltrigen Personen in der Liste steht. Dementsprechend hat die Reihenfolge der Personen in der Liste einen Einfluss auf das Ergebnis.

Gibt es allerdings nur eine jüngste Person (keine weiteren gleichaltrigen Personen), dann ist das Ergebnis eindeutig und unabhängig von der Reihenfolge in der Liste.

 

[distinct]

Zur Sicherheit noch die viel besser lesbare Stream-Variante:

import java.util.Arrays;
import java.util.Comparator;

public class Searching {
    record AlterUndPerson(int alter, String name) {
    }

    public static void main(String[] args) {
        AlterUndPerson[] alterUndPersonArray = {
                new AlterUndPerson(8, "Hänschen"),
                new AlterUndPerson(5, "Phillip"),
                new AlterUndPerson(99, "Gerda"),
                new AlterUndPerson(110, "Uroma"),
                new AlterUndPerson(14, "Donrat"),
                new AlterUndPerson(13, "Zzz"),
                new AlterUndPerson(8, "Miha"),
                new AlterUndPerson(5, "Pia"),
                new AlterUndPerson(5, "Ia"),
                new AlterUndPerson(10, "Hans")
        };
        Arrays.stream(alterUndPersonArray)
                .filter(aup -> aup.alter == Arrays.stream(alterUndPersonArray)
                        .min(Comparator.comparingInt(AlterUndPerson::alter))
                        .orElseThrow().alter)
                .forEach(System.out::println);
    }
}

 

[Oneixee5]

Zur Sicherheit noch die viel besser lesbare Stream-Variante:

import java.util.Arrays;
import java.util.Comparator;

public class Searching {
    record AlterUndPerson(int alter, String name) {
    }

    public static void main(String[] args) {
        AlterUndPerson[] alterUndPersonArray = {
                new AlterUndPerson(8, "Hänschen"),
                new AlterUndPerson(5, "Phillip"),
                new AlterUndPerson(99, "Gerda"),
                new AlterUndPerson(110, "Uroma"),
                new AlterUndPerson(14, "Donrat"),
                new AlterUndPerson(13, "Zzz"),
                new AlterUndPerson(8, "Miha"),
                new AlterUndPerson(5, "Pia"),
                new AlterUndPerson(5, "Ia"),
                new AlterUndPerson(10, "Hans")
        };
        Arrays.stream(alterUndPersonArray)
                .filter(aup -> aup.alter == Arrays.stream(alterUndPersonArray)
                        .min(Comparator.comparingInt(AlterUndPerson::alter))
                        .orElseThrow().alter)
                .forEach(System.out::println);
    }
}

Aber das ist doch ein Joke 🤦‍♂️

 

[Oneixee5]

Zur Sicherheit noch die viel besser lesbare Stream-Variante:

import java.util.Arrays;
import java.util.Comparator;

public class Searching {
    record AlterUndPerson(int alter, String name) {
    }

    public static void main(String[] args) {
        AlterUndPerson[] alterUndPersonArray = {
                new AlterUndPerson(8, "Hänschen"),
                new AlterUndPerson(5, "Phillip"),
                new AlterUndPerson(99, "Gerda"),
                new AlterUndPerson(110, "Uroma"),
                new AlterUndPerson(14, "Donrat"),
                new AlterUndPerson(13, "Zzz"),
                new AlterUndPerson(8, "Miha"),
                new AlterUndPerson(5, "Pia"),
                new AlterUndPerson(5, "Ia"),
                new AlterUndPerson(10, "Hans")
        };
        Arrays.stream(alterUndPersonArray)
                .filter(aup -> aup.alter == Arrays.stream(alterUndPersonArray)
                        .min(Comparator.comparingInt(AlterUndPerson::alter))
                        .orElseThrow().alter)
                .forEach(System.out::println);
    }
}

Wenn es unbedingt in einem Stream gelöst werden soll:

public class Main {

    record AlterUndPerson(int alter, String name) {
    }

    public static void main(final String[] args) {
        final AlterUndPerson[] alterUndPersonArray = {
                new AlterUndPerson(8, "Hänschen"),
                new AlterUndPerson(5, "Phillip"),
                new AlterUndPerson(99, "Gerda"),
                new AlterUndPerson(110, "Uroma"),
                new AlterUndPerson(14, "Donrat"),
                new AlterUndPerson(13, "Zzz"),
                new AlterUndPerson(8, "Miha"),
                new AlterUndPerson(5, "Pia"),
                new AlterUndPerson(5, "Ia"),
                new AlterUndPerson(10, "Hans")
        };

        Arrays.stream(alterUndPersonArray)
            .collect(Collectors.groupingBy(AlterUndPerson::alter))
            .entrySet()
            .stream()
            .min(Comparator.comparing(Entry::getKey))
            .get()
            .getValue()
            .forEach(System.out::println);
    }

}

 

[distinct]

jup, sieht besser aus, weil der innere Stream vermiden wird.

noch besser wäre es, vor dem Stream das Min. zu speichern. Aber dann wäre es nicht mehr funktional.

 

[Oneixee5]

MIr ist der Vorteil hier nicht ganz klar :

Um noch mal auf den Vorteil zu kommen. Ich würde es ohne Stream lösen:

        final var numbers = new ArrayList<Integer>();
            numbers.add(31);
            numbers.add(35);
            numbers.add(32);
            numbers.add(41);
            numbers.add(45);
            numbers.add(42);
            numbers.add(21);
            numbers.add(25);
            numbers.add(22);
            numbers.add(11);
            numbers.add(15);

        System.out.format("min: %s%n", Collections.min(numbers));

Einen Vorteil kann ich hier auch mit Comparator nicht erkennen, da Integer bereits Comparable<Integer> implementiert.

        System.out.format("min: %s%n", Collections.min(numbers, Comparator.naturalOrder()));

 

[mihe7]

IntSummaryStatistics stats = IntStream.of(31, 35, 32, 41, 45, 42, 21, 25, 22, 11, 15).summaryStatistics();
System.out.format("min: %d, max: %d%n", stats.getMin(), stats.getMax());

 

[distinct]

^- Das erzeugt nicht die gewünschte Ausgabe.

Man will ja wissen, wer alles am jüngsten bzw ältesten ist.

 

[mihe7]

Ne, das ist auf das Urproblem bzw. auf den Code aus #11 bezogen.

 

[distinct]

Dennoch, erst Grüppchen bilden, dann das minimalste Grüppchen bestimmen, dann das minimalste Grüppchen ausgeben lassen, sollte der richtigere Ansatz im Sinne der funktionalen Programmierung sein. 🙂

Nicht das langsame, hybride Konstrukt von mir ...

Wenn du eine rauchen möchtest, aber dein Feuerzeug ganz leer ist, würdest du auch jmd nach Feuer fragen, nicht nach Feuerzeuggas zum Nachfüllen, da Ersteres wahrscheinlicher ist, denke ich mal.

 

[mihe7]

Dennoch, erst Grüppchen bilden, dann das minimalste Grüppchen bestimmen, dann das minimalste Grüppchen ausgeben lassen, sollte der richtigere Ansatz im Sinne der funktionalen Programmierung sein. 🙂

Und ich dachte, die Cannabislegalisierung wäre noch nicht ganz durch.

Arrays.stream(alterUndPersonArray).min(Comparator.comparingInt(AlterUndPerson::alter)).ifPresent(System.out::println);

 

[distinct]

Wo bin ich und was mache ich hier? 🤣

Btw. Wer vor dem 1.1. schon rauch, gilt leider vor dem Gesetz als Krimineller...

 

[Oneixee5]

IntSummaryStatistics stats = IntStream.of(31, 35, 32, 41, 45, 42, 21, 25, 22, 11, 15).summaryStatistics();
System.out.format("min: %d, max: %d%n", stats.getMin(), stats.getMax());

Das ist nicht schlecht! IntSummaryStatistics hatte ich noch gar nicht so auf dem Schirm.