Optional<T> - NullPointerException

[werdas34]

Hallo,

mir macht die Klasse Optional Schwierigkeiten.
Optional nimmt einen Wert an oder null.
Hier die Methode:

    public String toString() {
        String str1 = "Voter{" + " Alter=" + getAge();
        if(!getParty().isPresent())    {
            return     str1 + " , Wahlkreis= " + ward + '}';   
        }
        return str1 + ", Partei= " + getParty() + " , Wahlkreis= " + ward + '}';
    }

getParty ist vom Typ Optional.
Wenn getParty einen gültigen Wert hat, dann funktioniert alles einwandfrei. Ist es jedoch null bekomme ich ne NullPointerException
Zeile 90 ist das: if(!getParty().isPresent()) {

Exceptions:
at Voter.toString(Voter.java:90)
at java.base/java.lang.String.valueOf(Unknown Source)
at java.base/java.io.PrintStream.println(Unknown Source)
at java.base/java.util.ArrayList$ArrayListSpliterator.forEachRemaining(Unknown Source)
at java.base/java.util.stream.ReferencePipeline$Head.forEach(Unknown Source)
at Voters.print(Voters.java:48)
at Main.main(Main.java:14)

Ich würde es verstehen wenn ich null ausgeben möchte, aber ich teste damit nur eine Bedingung.

Also entweder stell ich mich zu dumm an, oder ich versteh da was nicht.

Danke.
mfg werdas34

 

[Robat]

Sicher, dass das Optional an sich nicht null ist?

 

[mihe7]

Also entweder stell ich mich zu dumm an, oder ich versteh da was nicht.

Tja, entweder verliert man oder es gewinnen die anderen

Optional ist ein Objekt wie jedes andere. Wenn Du statt einem Optional einfach null zurückgibst, dann kannst Du Dir Optional gleich sparen. Vielmehr musst Du in der Methode, die null liefert, statt null ein Optional.empty() zurückgeben. Nachtrag: manchmal bietet sich auch an, den Rückgabewert mit Optional.ofNullable() zu erzeugen.

 

[werdas34]

Vielen Dank. Das erklärt einiges.
Keine Ahnung was ich mir dabei gedacht habe.

Wenn ich das ausgeben lasse kommt unteranderem das mit raus:
Voter{ Alter=22, Partei= Optional.empty , Wahlkreis= Oberfranken}
Woher kommt der Wert Optional.empty ?
Wie kann ich das prüfen? Bzw. was muss ich tun damit es nicht mehr auftaucht?

 

[mihe7]

Woher kommt der Wert Optional.empty ?

getParty()

Wie kann ich das prüfen? Bzw. was muss ich tun damit es nicht mehr auftaucht?

So, wie Du es oben schon gemacht hast: isPresent()

Ein Optional hat einen Wert oder eben nicht (ist leer). Hat es einen Wert, liefert isPresent() true, sonst false. Optional.empty().isPresent() liefert also false.

Optional.ofNullable(null) erzeugt ein Optional.empty(). Nachtrag: erzeugt das gleiche wie Optional.empty()

 

[werdas34]

Vielen Dank.
Ein Optional Objekt kann entweder den Wert(das Objekt) innehaben oder ein Optional.empty(null).

Nun eine etwas andere Frage:
Ich soll ein Prädikat schreiben, welches die Anzahl aller konservativen Wähler liefert.
So sieht mein Prädikat und der dazugehörige Stream aus:

        //Erstellen Sie ein Prädikat, das Ihnen die Anzahl aller konservativen Wähler liefert.
        final Predicate<Voter> allConservative = c -> {
            if(c.getParty().isPresent() && c.getParty().equals("Optional.empty")) {
                return c.getParty().get().isConservative();
            }
            return false;
        };
        System.out.println("---Alle konservativen Wähler---");
        System.out.println(voters.getVoters().stream()
                .filter(allConservative)
                .count());

Ich bekomme stets 0 ausgegeben, obwohl ein anderes Ergebnis erwartet wird.

Was habe ich falsch gemacht?

 

[Robat]

final Predicate<Voter> allConservative = c -> c.getParty().isPresent() && c.getParty().get().isConservative();

Sollte reichen. Es gibt keinen Grund getParty() mit einem String zu vergleichen. Du versuchst dort gerade Äpfel mit Birnen zu vergleichen.

 

[werdas34]

Deine Variante ist um einiges schicker als, das was ich versucht habe.

Führe ich diese aus, bekomme ich folgende Fehlermeldungen:
Exception in thread "main" java.util.NoSuchElementException: No value present
at java.base/java.util.Optional.get(Unknown Source)
at Main.lambda$3(Main.java:39)
at java.base/java.util.stream.ReferencePipeline$2$1.accept(Unknown Source)
at java.base/java.util.ArrayList$ArrayListSpliterator.forEachRemaining(Unknown Source)
at java.base/java.util.stream.AbstractPipeline.copyInto(Unknown Source)
at java.base/java.util.stream.AbstractPipeline.wrapAndCopyInto(Unknown Source)
at java.base/java.util.stream.ReduceOps$ReduceOp.evaluateSequential(Unknown Source)
at java.base/java.util.stream.ReduceOps$5.evaluateSequential(Unknown Source)
at java.base/java.util.stream.ReduceOps$5.evaluateSequential(Unknown Source)
at java.base/java.util.stream.AbstractPipeline.evaluate(Unknown Source)
at java.base/java.util.stream.ReferencePipeline.count(Unknown Source)
at Main.main(Main.java:43)

 

[mihe7]

Das kann eigentlich nicht sein.

 

[werdas34]

Das kann eigentlich nicht sein.

Mir wäre es auch lieber wenn es nicht so wäre.
Ist es halt leider nicht.

 

[mihe7]

Dann liefert getParty() bei Dir immer noch null.

 

[Xyz1]

dann kannst Du Dir Optional gleich sparen

Das dachte ich mir auch, in 98,1% aller Fälle ist das überflüssig!! Und in 1,9% der Fälle nur wenig hilfreich.

 

[mihe7]

Das kommt darauf an, wie man es anwendet. Es macht ja erstmal keinen Unterschied, ob man die Prüfung auf null oder die Prüfung auf isPresent vergisst. In beiden Fällen bekommt man eine ekelhafte Exception.

Mit ifPresent (mit f) und map wird die Sache dagegen wesentlich interessanter.

 

[werdas34]

Dann liefert getParty() bei Dir immer noch null.

    public Optional<Party> getParty() {
        final Party party = Party.getRandomOrNull();
        return Optional.ofNullable(party);
    }

So ist getParty() implementiert.
Party.getRandomOrNull():

    public static Party getRandomOrNull() {
        final Random random = new Random();
        if(random.nextInt(3) % 3 == 0 ) {
            return allParties.get(random.nextInt(allParties.size()));  
        }
        return null;
    }

Wenn es komplett mein eigener Code wäre, würde ich es ja anders lösen. Aber ich bin auf die Methodenköpfe vom Prof. angewiesen.

 

[Robat]

Zeig noch mal genau dein Predicate

 

[Xyz1]

bekommt man eine ekelhafte Ex

Ich denke er hat "Nullable" vergessen oder ein "OrNull" zu viel:

import java.util.Optional;
import java.util.function.Supplier;
import java.util.stream.Stream;

public class Opti1 implements Supplier<Optional<String>> {
    private final String iewas;

    public Opti1(String iewas) {
        this.iewas = iewas;
    }

    @Override
    public Optional<String> get() {
        return Optional.ofNullable(iewas);
    }

    public static void main(String[] args) {
        Stream.of("Hallo", null, "hallo")
                .map(Opti1::new)
                .map(Opti1::get)
                .map((t) -> t.orElse("Unbekannter"))
                .forEach((t) -> System.out.println("t = " + t));
    }
}

 

[werdas34]

Zeig noch mal genau dein Predicate

Das Predicate und seine Verwendung:

final Predicate<Voter> allConservative = c -> c.getParty().isPresent() && c.getParty().get().isConservative();
        System.out.println("---Alle konservativen Wähler---");
        System.out.println(voters.getVoters().stream()
                .filter(allConservative)
                .count());

Meine Aufgabe ist alle Konservativen zu zählen.

 

[Xyz1]

Wo issen das .orElse[Get](0)?

 

[werdas34]

Wo issen das .orElse[Get](0)?

Wozu brauch ich das?

 

[Xyz1]

Wozu brauch ich das

Nich so frech Bitte.

Jetzt verstehe ich das erst....
Alle Wähler, die ihr Kreuzchen bei Partei 3 machten:

import java.util.Optional;
import java.util.stream.Stream;

public class Opti1 {
    private final Integer waehler;

    public Opti1(Integer waehler) {
        this.waehler = waehler;
    }

    public Optional<Integer> isSomething() {
        return Optional.ofNullable(waehler);
    }

    public static void main(String[] args) {
        System.out.println(
                Stream.of(-1, 3, null, 3, 0)
                        .map(Opti1::new)
                        .map(Opti1::isSomething)
                        .filter((t) -> t.orElse(0) == 3)
                        .count());
    }
}

Fürs Predicate (t) -> t.orElse(0) == 3 brauchste es.

 

[Robat]

Wozu brauch ich das?

Eigentlich gar nicht.

Deinen Fehler kann ich nicht reproduzieren .. kleiner Test:

public static void main(String[] args)
    List<Voter> voters = new ArrayList<>();
    voters.add(new Voter(new Party(false)));
    voters.add(new Voter(new Party(true)));
    voters.add(new Voter(null));
    voters.add(new Voter(new Party(true)));
    voters.add(new Voter(null));

    System.out.println(voters.stream().filter(c -> c.getParty().isPresent() && c.getParty().get().isConservative()).count());
}

class Voter {
    private Party party;

    public Voter( Party party ) {
        this.party = party;
    }

    public Optional<Party> getParty() {
        return Optional.ofNullable(party);
    }
}

class Party {
    private boolean conservative;

    public Party( boolean conservative ) {
        this.conservative = conservative;
    }

    public boolean isConservative() {
        return conservative;
    }
}

 

[Xyz1]

Eigentlich gar nicht

Liest du meine Beiträger oder willst Du einfach Deinen Beitragszähler erhöhen?

 

[Robat]

Liest du meine Beiträger oder willst Du einfach Deinen Beitragszähler erhöhen?

Ich lese deine Beiträge schon, dennoch erklärt sich mir nicht wo man hier ein orElse benötigt... kann man wunderbar auch ohne umsetzen.
Da ich Diskussionen mit dir aber prinzipiell aus dem Weg gehe werd ich darauf nicht weiter eingehen. Du hast ja eh immer recht

 

[Xyz1]

Aber ich bin auf die Methodenköpfe vom Prof. angewiesen

Ach sorry, ich habe jetzt erst gelesen dass er die Methodennamensignaturen des Prof.s nicht ändern darf!!
Also.... Dann geht es trotzdem mit einem zusätzlichen map und dann auch mit orElse....
Das isPresent reduziert den Flow des stream ja lediglich auf ein boolean....

dennoch erklärt sich mir nicht wo man hier ein orElse benötigt

kein Ding, wir beide haben recht

Wo ist mihe eigentlich?

 

[mihe7]

Wo ist mihe eigentlich?

Rausch ausschlafen

 

[Xyz1]

Jetzt hast Du mich heiß gemacht....

    public Optional<Party> getParty() {
        final Party party = Party.getRandomOrNull();
        return Optional.ofNullable(party);
    }

So ist getParty() implementiert.
Party.getRandomOrNull():

    public static Party getRandomOrNull() {
        final Random random = new Random();
        if(random.nextInt(3) % 3 == 0 ) {
            return allParties.get(random.nextInt(allParties.size()));
        }
        return null;
    }

Wenn es komplett mein eigener Code wäre, würde ich es ja anders lösen. Aber ich bin auf die Methodenköpfe vom Prof. angewiesen.

Kannst Du einmal alles Gegebene in Java code Tag s packen und hier schreiben??
Mir ist das etwas zu umständlich alles nachzubilden
aber es sollte genau so mit .orElse() klappen!!

 

[Xyz1]

import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.Random;
import java.util.stream.IntStream;

public class Opti1 {
}

enum Party {
    placeholder, CDU, SPD, Gruene;
    private static final List<Party> allParties
            = Arrays.asList(Party.values());

    public Optional<Party> getParty() {
        final Party party = Party.getRandomOrNull();
        return Optional.ofNullable(party);
    }

    public static Party getRandomOrNull() {
        final Random random = new Random();
        if (random.nextInt(3) % 3 == 0) {
            return allParties.get(random.nextInt(allParties.size()));
        }
        return null;
    }

    public static void main(String[] args) {
        System.out.println(
                IntStream.range(0, 100)
                .boxed()
                .map((i) -> Party.placeholder.getParty())
                .filter((opt) -> opt.orElse(Party.placeholder) == Party.SPD)
                .count());
    }
}

und nacht

 

[mihe7]

Mir fällt gerade auf, dass random.nextInt(3) % 3 == 0 auch leicht unsinnig ist.

 

[Xyz1]

leicht unsinnig

Ja das stimmt,
dass getRandomOrNull static ist, getParty aber nich ist auch unsinnig
und dass allParties static sein muss ist auch unsinnig
und außerdem zusätzliche Unbekannte, zum Bleistift wissen wir nich wie equals() überschrieben wurde.

Den gegebenen code mal zu sehen wäre toll
zur Zeit musste ich mir das einfachstmögliche Fake bzw. SSCCE dazu ausdenken.
Und stochere damit natürlich etwas im Nebel....

 

[mihe7]

wissen wir nich

Wir wissen halt, wie immer, nix und davon viel

 

[werdas34]

Nich so frech Bitte.

Es war garnicht frecht gemeint.
Nur wenn mein Preidcate folgendermaßen ausschaut z.B.: Predicate<Voter> isOldies = o -> o.getAge() >=80;

Dann filter ich alles raus, die diese Bedingung erfüllen.
Was mir dann ein "entweder du bekommst den Wert, ansonsten eine 0" helfen sollte die Bedingung zu erfüllen, verstehe ich im Moment nicht.
Genauso frage ich mich, wie .map() mir helfen soll. Liegt aber wahrscheinlich daran, das ich sehr wenig Erfahrung mit Lambda und Streams habe (2 Vorlesungen und dies ist die erste Aufgabe).

Jetzt hast Du mich heiß gemacht....


Kannst Du einmal alles Gegebene in Java code Tag s packen und hier schreiben??
Mir ist das etwas zu umständlich alles nachzubilden
aber es sollte genau so mit .orElse() klappen!!

Folgt am Ende.

Mir fällt gerade auf, dass random.nextInt(3) % 3 == 0 auch leicht unsinnig ist.

Es sollten zufällig 1/3 der Voter einer Partei angehören. Also nicht immer jeder Dritte, aber am Ende ca 33%.

Ja das stimmt,
dass getRandomOrNull static ist, getParty aber nich ist auch unsinnig
und dass allParties static sein muss ist auch unsinnig

getRandomOrNull und getParty war so vorgegeben vom Prof.
allParties habe ich mit static hinzugefügt.

import java.util.List;
import java.util.Random;

/**
* Zugelassene Parteien fuer die Landtagswahl Bayern 2018.
*/

  
public enum Party {
    AfD(true), CSU(true), DieGruenen(false), FreieWaehler(true), DieLinke(false), FDP(false);
    /**
     * Flag: Partei zaehlt zu den konservativen Parteien (true) oder nicht (false).
     */
    private final boolean conservative;

    /**
     * Konstruktor fuer eine Partei.
     *
     * @param isConservative
     *            Partei ist konservativ (true) oder nicht (false).
     */
    Party(boolean isConservative) {
        this.conservative = isConservative;
    }

    public boolean isConservative() {
        return conservative;
    }

    /**
     * Liefert eine zufaellig ausgewaehlte Partei oder in einem Drittel der Faelle
     * null.
     *
     * @return eine Partei oder null.
     */
    public static Party getRandomOrNull() {
        // TODO: Hier fehlt Ihr Code
        final Random random = new Random();
        if(random.nextInt(3) % 3 == 0 ) {
            return allParties.get(random.nextInt(allParties.size()));  
        }
        return null;
    }

    /**
     * Liefert eine zufaellig ausgewaehlte Partei.
     *
     * @return eine Partei, niemals null.
     */
    static Party getRandom() {  
        // TODO: Hier fehlt Ihr Code
        final Random random = new Random();
        return allParties.get(random.nextInt(allParties.size()));
    }  
  
    /** Liste mit allen Parteien.
     *
     */
    public static final List<Party> allParties = List.of(AfD, CSU, DieGruenen, FreieWaehler, DieLinke, FDP);
}

import java.util.Objects;
import java.util.Optional;
import java.util.function.BiFunction;

/**
* Ein Waehler fuer die Landtagswahl Bayern.
*/
public class Voter {
    /** Wahlkreis. Nicht null. */
    private final Ward ward;
    /** Alter; nicht veraenderbar fuer die Wahlzeit. */
    private final int age;
    /** Parteizugehoerigkeit; null bedeutet keine. */
    private Party party = null;
    /** Wahlverhalten, so lange kein anderes festgelegt ist. */
    private BiFunction<Voter, Integer, Party> behaviour = VotingBehaviours.NO_VOTER;

    /**
     * Erzeugt einen Waehler.
     *
     * @param age
     *            Alter des Waehlers.
     * @param party
     *            Parteizugehoerigkeit des Waehlers, ev. keine d.h. null.
     * @param ward
     *            Wahlkreis des Waehlers.
     */
    public Voter(int age, Party party, Ward ward) {
        this.age = age;
        this.party = party;
        this.ward = Objects.requireNonNull(ward);
    }

    public int getAge() {
        return age;
    }

    public Ward getWard() {
        return ward;
    }

    /**
     * Liefert die Parteizugehoerigkeit des Waehlers.
     *
     * @return optionale Partei, ev. leer bei Parteilosen.
     */
    public Optional<Party> getParty() {
        // TODO: Hier fehlt Ihr Code
        final Party party = Party.getRandomOrNull();
        return Optional.ofNullable(party);
    }

    /**
     * Setzt die Parteizugehoerigkeit fuer einen Waehler.
     *
     * @param party
     *            Parteizugehoerigkeit fuer einen Waehler, ev. null.
     */
    public void setParty(Party party) {
        this.party = party;
    }

    @Override
    public int hashCode() {
        int hash = 3;
        hash = 97 * hash + this.getAge();
        hash = 97 * hash + Objects.hashCode(this.getParty());
        return hash;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        final Voter other = (Voter) obj;
        if (this.getAge() != other.getAge())
            return false;
        if (this.getParty() != other.getParty())
            return false;
        return true;
    }

    @Override
    public String toString() {
        return  "Voter{" + " Alter=" + getAge() + ", Partei= " + getParty() + ", Wahlkreis= " + ward + '}';
    }

    public void setBehaviour(BiFunction<Voter, Integer, Party> behaviour) {
        this.behaviour = behaviour;
    }

    /**
     * Partei, die dieser Waehler im gegebenen Jahr waehlt.
     *
     * @param year
     *            der Wahl.
     * @return gewaehlte Partei, nicht null.
     */
    public Party vote(int year) {
        // TODO: Hier fehlt Ihr Code
      
        return this.behaviour.apply(this, year);
    }
}

import java.util.List;
import java.util.Random;

/**
* Wahlkreise fuer die Bayernwahl 2018.
*/
public enum Ward {
    Oberbayern, Niederbayern, Oberpfalz, Oberfranken, Mittelfranken, Unterfranken, Schwaben;
    /**
     * Liefert einen zufaellig ausgewaehlten Wahlkreis.
     *
     * @return ein Wahlkreis, nicht null.
     */
    public static Ward getRandom() {
        // TODO: Hier fehlt Ihr Code
        final Random random = new Random();
        return allWards.get(random.nextInt(allWards.size()));
    }
    /**Alle Wahlkreise.
     *
     */
    public static final List<Ward> allWards = List.of(Oberbayern, Niederbayern, Oberpfalz, Oberfranken, Mittelfranken, Unterfranken, Schwaben);
}

import java.util.List;
import java.util.function.BiFunction;

/**
* Wahlverhalten eines Waehlers.
*/
public class VotingBehaviours {
    /**
     * Waehler, der nicht waehlt. Ein Lambdaausdruck fuer eine Runtime Exception.
     */
    public static final BiFunction<Voter, Integer, Party> NO_VOTER = (voter, year) -> {
        throw new RuntimeException("I cannot decide yet");
    };
  
    /**
     * Gewaehlt wird immer die CSU.
     */
    public static final BiFunction<Voter, Integer, Party> AMIGO_VOTER = (voter, year) -> Party.CSU;
  
  
  
  
  
  
    /**Gewaehlt wird die Parteizugehoerigkeit, falls es keine
     * Parteizufehoerigkeit gibt, eine Zufallspartei.
     */
    public static final BiFunction<Voter, Integer, Party> MY_PARTY_OR_RANDOM = (voter, year) -> voter.getParty().orElse(Party.getRandom());
            // TODO: Hier fehlt Ihr Code
  

  
  
    /**
     * Die Partei des Jahres wird bestimmt.
     * @param year Das aktuelle Jahr.
     * @return Die Partei des aktuellen Jahres.
     */
    public static Party partyOfTheYear(int year) {
        int random = year % Party.allParties.size();
        return Party.allParties.get(random);
    }
    /**Gewaehlt wird die Partei des Jahres.
     */
    public static final BiFunction<Voter, Integer, Party> PARTY_OF_THE_YEAR = (voter, year) -> partyOfTheYear(year);
            // TODO: Hier fehlt Ihr Code
      
  
          
          
          
    /**Gewaehlt wird irgend eine Partei.
     *
     */
    public static final BiFunction<Voter, Integer, Party>VOTE_GAGA = (voter, Integer) -> Party.getRandom();
            // TODO: Hier fehlt Ihr Code

  
    /**
     * Liste aller gueltigen Wahlverhalten.
     */
    public static final List<BiFunction<Voter, Integer, Party>> VALID_BEHAVIOURS = List.of(MY_PARTY_OR_RANDOM, PARTY_OF_THE_YEAR,
            VOTE_GAGA, AMIGO_VOTER);
}


import java.util.Collections;
import java.util.List;
import java.util.Random;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
* Liste mit zufälligen Wählern.
* @author schda
*
*/
public class Voters {
  
    /**
     * Mehrere Voters.
     */
    private List<Voter> voters;
  
    /**
     * Randommaschine.
     */
    private Random random = new Random();
  
    /**
     * Liste über eine zufällige Wählerschaft mit zufälligem Alter, zufälliger Parteizugehörigkeit (auch null) und zufälligem Wahlkreis.
     * @param limit Anzahl der Wähler.
     */
    public Voters(int limit) {
        this.voters = Stream.generate(() -> new Voter(random.nextInt(72) + 18, Party.getRandomOrNull(), Ward.getRandom()))
                .limit(limit)
                .collect(Collectors.toList());
    }
  
    /**
     * Liefert die Liste der Voters unmodifiabled zurück.
     * @return Liste von Voters.
     */
    public List<Voter> getVoters(){
        return Collections.unmodifiableList(voters);
    }
  
    /**
     * Gibt alle Voters aus.
     */
    public void print() {
        final Stream<Voter> streamVoter = this.voters.stream();
      
        streamVoter.forEach(System.out::println);
    }
}


import java.util.Optional;
import java.util.Random;
import java.util.function.Predicate;
import java.util.stream.Stream;

/**
* Main-Task.
* @author schda
*
*/
public class Main {
    /**
     * Das aktuelle Jahr.
     */
    static final int currentYear = 2018;
/**
* Startmethode.
* @param args darf alles sein.
*/
    public static void main(String[] args) {
        Random random = new Random();
      
        Voters voters = new Voters(100);
        voters.print();
      
        final Predicate<Voter> isOldies = o -> o.getAge() >=80;
        final Stream<Voter> oldies = voters.getVoters().stream()
                .filter(isOldies);
        System.out.println("-----Oldies------");
        oldies.forEach(System.out::println);  
      
        System.out.println("---Wahlkreis Niederbayern----");
        System.out.println(voters.getVoters().stream()
                .filter(w -> w.getWard().equals(Ward.Niederbayern))
                .count());      

        final Predicate<Voter> allConservative = c -> c.getParty().isPresent() && c.getParty().get().isConservative();
        System.out.println("---Alle konservativen Wähler---");
        System.out.println(voters.getVoters().stream()
                .filter(allConservative)
                .count());
      
          
      
      
      
        //-----------------------------------------------------------------------------------------------
        voters.getVoters().stream().forEach(v -> v.setBehaviour(VotingBehaviours.VALID_BEHAVIOURS.get(random.nextInt(VotingBehaviours.VALID_BEHAVIOURS.size()))));
      
      
      
        System.out.println("---Stimmen für AfD---");
        System.out.println(voters.getVoters().stream()
                .filter(c -> c.vote(currentYear) == Party.AfD)
                .count() + "/" + voters.getVoters().size());
      
        System.out.println("---Stimmen für CSU---");
        System.out.println(voters.getVoters().stream()
                .filter(c -> c.vote(currentYear) == Party.CSU)
                .count() + "/" + voters.getVoters().size());
      
        System.out.println("---Stimmen für DieGruenen---");
        System.out.println(voters.getVoters().stream()
                .filter(c -> c.vote(currentYear) == Party.DieGruenen)
                .count() + "/" + voters.getVoters().size());
      
        System.out.println("---Stimmen für AfD---");
        System.out.println(voters.getVoters().stream()
                .filter(c -> c.vote(currentYear) == Party.AfD)
                .count() + "/" + voters.getVoters().size());
      
        System.out.println("---Stimmen für FreieWaehler---");
        System.out.println(voters.getVoters().stream()
                .filter(c -> c.vote(currentYear) == Party.FreieWaehler)
                .count() + "/" + voters.getVoters().size());
      
        System.out.println("---Stimmen für DieLinke---");
        System.out.println(voters.getVoters().stream()
                .filter(c -> c.vote(currentYear) == Party.DieLinke)
                .count() + "/" + voters.getVoters().size());
      
        System.out.println("---Stimmen für FDP---");
        System.out.println(voters.getVoters().stream()
                .filter(c -> c.vote(currentYear) == Party.FDP)
                .count() + "/" + voters.getVoters().size());
      
      

    }
}

Dies ist der letzte Stand. Also der Fehler tritt immer noch auf. Ich habe nichts mit orElse und map gemacht, da ich wie oben erwähnt nicht weiß, wie ich das verwenden muss.
Die Klassen Voters und Main stammen komplett von mir. Der Rest stammt zum großteil vom Prof.

 

[mihe7]

Es sollten zufällig 1/3 der Voter einer Partei angehören. Also nicht immer jeder Dritte, aber am Ende ca 33%.

Es ist 0 <= nextInt(3) <= 2. Daraus folgt: nextInt(3) == (nextInt(3) % 3); der Modulo-Operator ist nicht falsch, er ist eben nur "leicht unsinnig"

 

[Xyz1]

Es ist 0 <= nextInt(3) <= 2. Daraus folgt: nextInt(3) == (nextInt(3) % 3); der Modulo-Operator ist nicht falsch, er ist eben nur "leicht unsinnig"

es

Aber genau das gleiche wollte ich auch schreiben....

Sooooo - mit enum lag ich richtig, demzufolge ist die Frage schon beantwortet....

wie .map() mir helfen soll

Gar nicht - damit ich alles in eine Zeile packen konnte war das....

Und auch eine Beleidigung kann "nicht frech gemeint sein" aber sehr wohl als solche wahrgenommen werden....

 

[mihe7]

Also der Fehler tritt immer noch auf.

@werdas34 OMG, bin ich blöd. Du rufst ja zweimal getParty() auf und darin wird jedesmal per Zufall ein Ergebnis zurückgegeben... es kann also durchaus passieren, dass in Deinem Predicate beim ersten Aufruf c.getParty() isPresent() gilt, während beim zweiten Aufruf (nach der &&-Verknüpfung) c.getParty() !isPresent() gilt.

 

[Robat]

Du rufst ja zweimal getParty() auf und darin wird jedesmal per Zufall ein Ergebnis zurückgegeben

LOL ... an manche Dinge denkt man einfach gar nicht wenn man den Code nur 1 mal anschaut ...

 

[Xyz1]

Also ich hatte mit dem von Euch verschmähtem .orElse() daran gedacht.

 

[mihe7]

Es ist ja auch nicht so, dass man die Zeile nur einmal gelesen hätte... wie war das mit % 3?!?

 

[Xyz1]

wie war das mit % 3

3 % ist aber jetzt schon eine Überschätzung um 57,89 %