List & ArrayList nach Familiennamen abfragen

[Neumi5694]

Person ist eine Record, damit könnte es folgendermaßen funktionieren:

Ah, die Zeile hab ich übersehen. Dann natürlich ohne get...

 

[Neumi5694]

Grundsätzlicher Ansatzfehler: Das Suchergebnis innerhalb der Schleife ausgeben.
Besserer Ansatz: Das Suchergebnis innerhalb der Schleife bestimmen. Falls gefunden, Ergebnis notieren und Schleife abbrechen.
Nach der Schleife prüfen, ob was gefunden wurde und gegebenenfalls ausgeben - oder eben die Fehlermeldung.

Ich versteh nicht, warum all die Übungsaufgaben immer System.out.println()s direkt in Schleifen haben. Dann wundern sich die Leute immer, warum der Code nicht ordentlich funktioniert. Es ist einfach sinnvoller, Algorithmus und Ausgabe zu trennen - selbst bei so einfachen Beispielen.

private Optional<Person> findPerson(...) {
    //for-each Schleife über alle persons
    for (var person : persons) {
        //Bei Übereinstimmung: return Optional.of(...);
        if (...) {
            return Optional.of(person);
        }
    }
    //Falls nichts gefunden (nach der Schleife, der Punkt wird nur dann erreicht): return Optional.empty();
    return Optional.empty();
}

void myMethod() {
    var p = findPerson(...);
    if (p.isPresent()) { //es wurde was gefunden
        //Erfolgsmeldung, die Person kriegt man mit p.get()
    } else { //nichts gefunden
        //Fehlermeldung
    }
}

Das geht natürlich auch mit einer null-Rückgabe anstatt Optional, aber ich finde Optional einfach schöner.

 

[KonradN]

So sehr mich gestört hat, dass der TE auf Hinweise nicht eingeht und an seiner Lösung so wehement festhält: So ein Quatsch bringt niemandem etwas.

Also eine mögliche Unterteilung in Methoden könnte dann z.B. so aussehen:

import java.util.List;

public class PersonenVerwaltung {
    
    // Der Record gehört als public record Person .... in eine eigene Datei Person.java.
    // Aber hier geht es nur um Code in dieser einen Datei, daher für diese Übung ok. 
    record Person(String famname, String vorname, int alter) {}
    
    // Alles läuft in der main - das sollte man auch nur am Anfang so machen.
    // Später sollte man Objektorientiert arbeiten, d.h. von den Klassen wird eine Instanz erstellt, mit denen man dann etwas macht.
    public static void main(String... args) {
        final List<Person> persons =  List.of(
                new Person("Maier", "Bernd", 11),
                new Person("Hofer", "Melita", 12),
                new Person("Felsner", "Heidy", 13));

        for(int i = 0; i < persons.size(); i++) {
            System.out.println(persons.get(i));
        }

        System.out.println();

        // Jetzt eine einfache Methode, die sich um die Eingabe kümmert.
        String nameToFind = getInput("Eingabe:");

        // Jetzt eine einfache Methode, die sich um die Suche kümmert.
        Person foundPerson = findPerson(persons, nameToFind);

        // Und dann auch eine Methode zur Ausgabe:
        print(foundPerson);
    }

    public static void print(Person person) {
        if (person != null) {
            System.out.println(person.vorname + " " + person.famname);
        } else {
            System.out.println("Person wurde nicht gefunden!");
        }
    }
    
    public static String getInput(String message) {
        while (true) {
            String eingabe = javax.swing.JOptionPane.showInputDialog(message);
            if (eingabe != null && !eingabe.isEmpty()) {
                return eingabe;
            }
            
            System.out.println("Ungültige Eingabe!");
        }
    }
    
    public static Person findPerson(List<Person> persons, String name) {
        if (persons == null) throw new IllegalArgumentException("Persons cannot be null!");
        if (name == null || name.isEmpty()) return null;

        for (final Person pers : persons) {
            if(pers.famname.equalsIgnoreCase(name)) {
                return pers;
            }
        }

        return null;
    }
}

Hier sind Aufgaben in Methoden aufgetelt worden. Jede dieser Methoden ist einfach und übersichtlich. Die Methoden könnten dann auch getestet werden und ggf. könnnen dieser wieder verwendet werden (z.B. die getInput Methode kannst Du an beliebigen Stellen verwenden.)

Du kannst dann auch genau da, wo Du es brauchst, auf Dinge reagieren. Als Beispiel habe ich einfach mal in der Eingabe so lange gefragt, bis eine gültige Antwort angegeben wurde (So eher unüblich, ab zu demonstrationszwecken ok denke ich mal).

Wenn man dann später etwas größere Dinge schreiben sollte, dann kann man die Methoden auch gut immer dahin packen, wo sie hin gehören. Es gibt ann also eine gute Gliederung in Klassen. Aber das wirst Du auch später sehen.

Wichtig ist halt wirklich diese Unterteilung. Divide and conquer - Teile und herrsche! Durch die Unterteilung in kleine Aufgaben machst Du Dir das Leben einfach. Und es entspricht dem normalen Vorgehen:

Schreib Dir nur auf, was Du machen willst:
1. Nutzer nach Eingabe fragen
2. Person suchen
3. gefundene Person augeben.

Und dann erst verfeinerst Du: Was genau musst Du denn bei der Eingabe machen? Wie genau musst Du die Person suchen? Wie genau gibst Du die Person aus? Das kannst Du nun jeden Punkt für sich separat abhandeln.

 

[Staarfightaar]

So sehr mich gestört hat, dass der TE auf Hinweise nicht eingeht und an seiner Lösung so wehement festhält: So ein Quatsch bringt niemandem etwas.

Also eine mögliche Unterteilung in Methoden könnte dann z.B. so aussehen:

import java.util.List;

public class PersonenVerwaltung {
   
    // Der Record gehört als public record Person .... in eine eigene Datei Person.java.
    // Aber hier geht es nur um Code in dieser einen Datei, daher für diese Übung ok.
    record Person(String famname, String vorname, int alter) {}
   
    // Alles läuft in der main - das sollte man auch nur am Anfang so machen.
    // Später sollte man Objektorientiert arbeiten, d.h. von den Klassen wird eine Instanz erstellt, mit denen man dann etwas macht.
    public static void main(String... args) {
        final List<Person> persons =  List.of(
                new Person("Maier", "Bernd", 11),
                new Person("Hofer", "Melita", 12),
                new Person("Felsner", "Heidy", 13));

        for(int i = 0; i < persons.size(); i++) {
            System.out.println(persons.get(i));
        }

        System.out.println();

        // Jetzt eine einfache Methode, die sich um die Eingabe kümmert.
        String nameToFind = getInput("Eingabe:");

        // Jetzt eine einfache Methode, die sich um die Suche kümmert.
        Person foundPerson = findPerson(persons, nameToFind);

        // Und dann auch eine Methode zur Ausgabe:
        print(foundPerson);
    }

    public static void print(Person person) {
        if (person != null) {
            System.out.println(person.vorname + " " + person.famname);
        } else {
            System.out.println("Person wurde nicht gefunden!");
        }
    }
   
    public static String getInput(String message) {
        while (true) {
            String eingabe = javax.swing.JOptionPane.showInputDialog(message);
            if (eingabe != null && !eingabe.isEmpty()) {
                return eingabe;
            }
           
            System.out.println("Ungültige Eingabe!");
        }
    }
   
    public static Person findPerson(List<Person> persons, String name) {
        if (persons == null) throw new IllegalArgumentException("Persons cannot be null!");
        if (name == null || name.isEmpty()) return null;

        for (final Person pers : persons) {
            if(pers.famname.equalsIgnoreCase(name)) {
                return pers;
            }
        }

        return null;
    }
}

Objects.requireNonNull(persons,
                "persons can't be null.")
würde ich austauschen bei 
        if (persons == null) throw new IllegalArgumentException("Persons cannot be null!");

und bei

  public static void print(Person person) {

        if (person != null) {

            System.out.println(person.vorname + " " + person.famname);

        } else {

            System.out.println("Person wurde nicht gefunden!");

        }

    }

würde ich es umbauen zu

  public static void print(Person person) {
        String output = person != null ? person.vorname + " " + person.famname : "Peerson wurde nicht gefunden!";
          System.out.println(output);
      

    }

einfach aus dem grund wenn ich den output ändere von out println auf nen filewriter muss ich das system.out.println 2 mal ändern, so nur einmal

 

[KonradN]

Also hier sollte man nicht aus den Augen verlieren, dass wir in einem Thread mit einem Beginner sind. Hier geht es also gezielt um ein Verständnis, was man wie macht. Und das auch stark begrenzt auf eben das, was er nachvollziehen können sollte. Was ist also wie wichtig? Für mich steht das Teile und Herrsche ganz oben - das MUSS er verstehen, wenn er wirklich weiter kommen will.

Die anderen Dinge sind nebensächlich, aber wir können dies gerne einmal anschauen (@volcanos Das musst Du jetzt nicht verstehen. Das kommt sehr viel später!):

einfach aus dem grund wenn ich den output ändere von out println auf nen filewriter muss ich das system.out.println 2 mal ändern, so nur einmal

Also wenn Du sowas schon anpacken willst, dann würde ich dies doch richtig anpacken. Das Kernproblem, das Du doch identifiziert hast (Wenn ich Deine Begründung betrachte): Die Abhängigkeit zu Sytem.out. Wie gehst Du denn mit so Abhängigkeiten um? Gerade auch im Hinblick auf Unit Tests und so?

Da wäre doch eher etwas wie z.B. dieser Code zielführend:

import java.io.PrintStream;

public class Ausgabe {
    private final PrintStream out;

    public Ausgabe() {
        this(System.out);
    }

    public Ausgabe(final PrintStream out) {
        this.out = out;
    }

    public void print(final Person person) {
        if (person != null) {
            out.println(person.vorname + " " + person.famname);
        } else {
            out.println("Person wurde nicht gefunden!");
        }
    }
}

Die Abhängigkeit wird also per Konstruktor injected und kann damit einfach getestet werden.

Ansonsten wäre deine Umstellung lediglich eine Frage: if oder Ternärer Operator? Und ein Argument ist ein Ausdruck mit mehreren Operatoren - Das macht den Ternären Operator unübersichtlich und daher wäre der dann auf 3 Zeilen aufzuteilen damit klar ist, wo welcher Block endet. Kann man machen, würde ich nicht machen. Sehe ich aber keinen wirklichen Unterschied. Außer eben bezüglich Zielgruppe - da würde ich es immer vermeiden.

Die Validierung kann man so machen, wie man will. Hier wäre maximal die typische Herangehensweise bei Anfängern: Wir validieren nichts
Wenn eine Validierung einem Anfänger gezeigt wird, dann sollte diese gut lesbar sein. Daher die Wahl meiner Variante.
Ansonsten ist die Validierung meist nur eine Annotation (Etwas, wo ich von Java enttäuscht bin: Es werden weiterhin massiv Codes geschrieben, die einfach nur unsinniger Schreibkram sind und die man sich sparen kann. Records sind da schon ein guter Ansatz aber generell sind manche Dinge sehr unschön. Und gewisse Dinge kann man sich durchaus abschauen von anderen Sprachen um dann ähnliche Konstrukte einzuführen ...)

 

[Staarfightaar]

du hast halt den annotationen jungel in java weil gefühlt alles über annotationen geht

dann hast schonmal eine methode mit 2 zeilen code und 10 annotationen ob das jetzt so zielführend ist puh...

zb icch mach meine 2 annotationen, dann noch 2 von lombok dazu und dann noch 3 von spring... und schwups hat man die kontrolle über sein leben verloren

Bei records fallen halt gezielt annotationen weg und es wird schlank und rank aber das ist halt eine syntax die die magier von java einführen müssen und da ist java gefühlt immer hinterher

 

[Oneixee5]

Ich denke da es um eine Liste von Personen geht ist die Reduzierung auf einen Treffer nicht korrekt. Die Variante mit System.out.println deckt das auch ab. Das Vorgehen ist einfach und effizient.

 

[Neumi5694]

Wenn's um eine Liste geht, dann wird halt eine Liste als Returnwert geliefert. Logik und Ausgabe sind auf jeden Fall zu trennen, dann klappts auch mit den Fehlermeldungen.