Schleifen in Java 8 loswerden

Der in Java 8 eingeführte funktionale Stil ist eine großartige Ergänzung der Sprache. Nun ist Java kein reines OOP, sondern eine Mischung aus OOP und funktionaler Programmierung. Dies ist ein Game Changer und wir müssen unser OOP-Gehirn ändern, um diese Veränderungen zu absorbieren. Aber warum sollten wir diese Veränderungen akzeptieren? Warum sollten wir Zeit damit verschwenden, mit einem funktionalen Stil zurechtzukommen, wenn wir das Problem mit reinem OOP lösen können?

• Der in Java 8 eingeführte funktionale Stil hilft uns, die Lücke zwischen Geschäftslogik und Code zu verringern. Es ermöglicht uns, die Geschichte in einem natürlichen Fluss auf einer höheren Ebene zu erzählen. Anstatt zu sagen, wie Sie es tun möchten, können Sie sagen, was Sie tun möchten.

• Der Code wird sauberer und prägnanter.

• Funktionen höherer Ordnung ermöglichen uns:

  • Senden Sie Funktionen an andere Funktionen
  • Erstellen Sie Funktionen innerhalb anderer Funktionen
  • Rückgabefunktionen von anderen Funktionen

  Dies ist ein großer Gewinn für Java, wo wir dazu Objekte senden, erstellen und zurückgeben müssen. Wir werden in der Lage sein, Code zu schreiben, der zuverlässiger, fokussierter und einfacher wiederzuverwenden ist.

• Dank Lambdas können wir verzögerte Berechnungen durchführen. Wenn ein Lambda-Ausdruck als Methodenargument gesendet wird, wertet der Compiler ihn aus, wenn er in der Methode aufgerufen wird. Dies unterscheidet sich von normalen Methodenargumenten, die sofort ausgewertet werden.

• Mit Lambdas macht das Schreiben von Unit-Tests Spaß. Sie ermöglichen uns die Erstellung einfacher Tests, die sauber, klein und schnell zu schreiben sind. Wir können den zu testenden Code mithilfe von Lambdas ausrotten. Dadurch können wir testen, wie sich verschiedenste Szenarien auf den Code auswirken.

• Neue Muster zum Lernen.

• Und vieles mehr!

Aber genug Wasser, in diesem Artikel werfen wir einen Blick auf alternative Lösungen zu herkömmlichen Kreisläufen. Natürlich sind die Zyklen flexibel, aber das hat seinen Preis. break, verändern das Verhalten der Schleife dramatisch und zwingen uns, nicht nur zu verstehen, was der Code erreichen möchte, continuesondern returnauch zu verstehen, wie die Schleife funktioniert. Jetzt werfen wir einen Blick darauf, wie wir Schleifen in prägnanteren und lesbareren Code umwandeln können.

Lasst die Codierung beginnen!

Wir werden mit Artikeln arbeiten. Ein Artikel hat einen Titel, einen Autor und mehrere Tags.

private class Article {

    private final String title;
    private final String author;
    private final List<String> tags;

    private Article(String title, String author, List<String> tags) {
        this.title = title;
        this.author = author;
        this.tags = tags;
    }

    public String getTitle() {
        return title;
    }

    public String getAuthor() {
        return author;
    }

    public List<String> getTags() {
        return tags;
    }
}

Jedes Beispiel enthält eine traditionelle Lösung mit Schleifen und eine Lösung mit den neuen Funktionen von Java 8. Im ersten Beispiel möchten wir den ersten Artikel in der Sammlung mit dem Tag „Java“ finden. Schauen wir uns eine Lösung mit einer Schleife an.

public Article getFirstJavaArticle() {

    for (Article article : articles) {
        if (article.getTags().contains("Java")) {
            return article;
        }
    }
    return null;
}

Lassen Sie uns nun das Problem mithilfe von Vorgängen aus der Stream-API lösen.

public Optional<Article> getFirstJavaArticle() {
    return articles.stream()
        .filter(article -> article.getTags().contains("Java"))
        .findFirst();
    }

Ziemlich cool, nicht wahr? Wir verwenden die Operation zunächst, filterum alle Artikel mit dem Tag „Java“ zu finden, und verwenden sie dann, findFirst()um das erste Vorkommen zu ermitteln. Da Streams verzögert sind und der Filter einen Stream zurückgibt, verarbeitet dieser Ansatz nur Elemente, bis die erste Übereinstimmung gefunden wird. Lassen Sie uns nun alle Artikel mit dem Tag „Java“ versehen und nicht nur den ersten. Zuerst die Lösung mit Schleifen.

public List<Article> getAllJavaArticles() {

    List<Article> result = new ArrayList<>();

    for (Article article : articles) {
        if (article.getTags().contains("Java")) {
            result.add(article);
        }
    }
    return result;
}

Lösung mit Stream-Operationen.

public List<Article> getAllJavaArticles() {
    return articles.stream()
        .filter(article -> article.getTags().contains("Java"))
        .collect(Collectors.toList());
    }

In diesem Beispiel haben wir eine Operation verwendet, collectum den resultierenden Stream zu verkürzen, anstatt eine Sammlung zu deklarieren und die übereinstimmenden Einträge explizit hinzuzufügen. So weit, ist es gut. Zeit für Beispiele, die die Stream-API wirklich zum Leuchten bringen. Lassen Sie uns alle Artikel nach Autor gruppieren. Wie üblich beginnen wir damit, es mithilfe von Schleifen zu lösen:

public Map<String, List<Article>> groupByAuthor() {

    Map<String, List<Article>> result = new HashMap<>();

    for (Article article : articles) {
        if (result.containsKey(article.getAuthor())) {
            result.get(article.getAuthor()).add(article);
        } else {
            ArrayList<Article> articles = new ArrayList<>();
            articles.add(article);
            result.put(article.getAuthor(), articles);
        }
    }
    return result;
}

Können wir mithilfe von Stream-Operationen eine saubere Lösung für dieses Problem finden?

public Map<String, List<Article>> groupByAuthor() {
    return articles.stream()
        .collect(Collectors.groupingBy(Article::getAuthor));
}

Toll! Durch die Verwendung einer Operation groupingByund einer Methodenreferenz getAuthor()erhalten wir sauberen und lesbaren Code. Suchen wir nun nach den restlichen Tags, die in der Sammlung verwendet werden. Beginnen wir mit einem Schleifenbeispiel:

public Set<String> getDistinctTags() {

    Set<String> result = new HashSet<>();

    for (Article article : articles) {
        result.addAll(article.getTags());
    }
    return result;
}

Okay, schauen wir uns an, wie wir dieses Problem mithilfe von Stream-Operationen lösen können:

public Set<String> getDistinctTags() {
    return articles.stream()
        .flatMap(article -> article.getTags().stream())
        .collect(Collectors.toSet());
}

Cool! flatmaphilft uns, die Liste der Tags in einen einzigen Ergebnisstrom zu reduzieren, den wir dann collectzum Erstellen des Rückgabesatzes verwenden.

Endlose Möglichkeiten

Dies waren 4 Beispiele dafür, wie Schleifen durch besser lesbaren Code ersetzt werden können. Schauen Sie sich unbedingt die Stream-API an, da dieser Artikel nur an der Oberfläche kratzt. Die Beherrschung des neuen Funktionsstils von Java wird für OOP-Entwickler eine Herausforderung sein, aber es ist eine Herausforderung, die gut angenommen werden sollte. Ich gehe sogar so weit zu sagen, dass man eine rein funktionale Programmiersprache lernen sollte. Auf diese Weise können Sie die Möglichkeiten und die Leistung, die es bietet, vollständig verstehen. Ich denke, das wird Ihnen helfen, die funktionale Programmierung auf einer anderen Ebene zu verstehen. Lernen Sie also funktionale Programmierung zusammen mit dem guten alten OOP und nutzen Sie beide, um noch besseren Code zu schreiben! Eine kostenlose Mischung aus Übersetzungen von zwei Artikeln – Warum Sie funktionale Programmierung in Java 8 nutzen sollten und Abkehr von Schleifen in Java 8