Pag-alis ng mga loop sa Java 8

Ang functional na istilo na ipinakilala sa Java 8 ay isang mahusay na karagdagan sa wika. Ngayon ang Java ay hindi purong OOP, ngayon ito ay isang hybrid ng OOP at functional programming. Ito ay isang game changer at kailangan nating baguhin ang ating OOP brains para makuha ang mga pagbabagong ito. Ngunit bakit dapat nating tanggapin ang mga pagbabagong ito? Bakit tayo mag-aaksaya ng oras sa pagsisikap na makibagay sa isang functional na istilo kapag malulutas natin ang problema gamit ang purong OOP?

• Ang functional na istilo na ipinakilala sa Java 8 ay tumutulong sa amin na bawasan ang agwat sa pagitan ng lohika ng negosyo at code. Ito ay nagpapahintulot sa amin na sabihin ang kuwento sa isang natural na daloy sa isang mas mataas na antas. Sa halip na sabihin kung paano mo gustong gawin ito, maaari mong sabihin kung ano ang gusto mong gawin.

• Ang code ay nagiging mas malinis at mas maigsi.

• Nagbibigay-daan sa amin ang mga high order function na:

  • Magpadala ng mga function sa iba pang mga function
  • Lumikha ng mga function sa loob ng iba pang mga function
  • Ibalik ang mga function mula sa iba pang mga function

  Malaking panalo ito para sa Java, kung saan kailangan nating magpadala, gumawa, at magbalik ng mga bagay para magawa ito. Magagawa naming magsulat ng code na mas maaasahan, nakatuon, at mas madaling gamitin muli.

• Salamat sa lambdas, makakagawa tayo ng mga tamad na kalkulasyon. Kapag ipinadala ang isang lambda expression bilang argumento ng pamamaraan, susuriin ito ng compiler kapag tinawag ito sa pamamaraan. Iba ito sa mga karaniwang argumento ng pamamaraan, na agad na sinusuri.

• Ginagawa ng Lambdas na masaya ang pagsusulat ng mga pagsubok sa unit. Nagbibigay-daan sila sa amin na gumawa ng mga magaan na pagsubok na malinis, maliit ang laki, at mabilis na magsulat. Maaari naming i-root out ang code sa ilalim ng pagsubok gamit ang lambdas. Nagbibigay-daan ito sa amin na subukan kung paano makakaapekto sa code ang lahat ng uri ng mga sitwasyon.

• Mga bagong pattern upang matutunan.

• At marami pang iba!

Ngunit sapat na tubig, sa artikulong ito ay titingnan natin ang mga alternatibong solusyon sa tradisyonal na mga siklo. Siyempre, ang mga cycle ay nababaluktot, ngunit hindi ito darating nang walang presyo. break, kapansin-pansing baguhin ang pag-uugali ng loop, na pinipilit kaming maunawaan hindi lamang kung ano ang sinusubukang makamit ng code, continuengunit returnupang maunawaan din kung paano gumagana ang loop. Ngayon ay titingnan natin kung paano natin mababago ang mga loop sa mas maigsi at nababasang code.

Hayaang magsimula ang coding!

Makikipagtulungan kami sa mga artikulo. Ang isang artikulo ay may pamagat, may-akda at ilang mga tag.

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;
    }
}

Ang bawat halimbawa ay maglalaman ng tradisyonal na solusyon gamit ang mga loop at solusyon gamit ang mga bagong feature ng Java 8. Sa unang halimbawa, gusto naming hanapin ang unang artikulo sa koleksyon na may tag na "Java". Tingnan natin ang isang solusyon gamit ang isang loop.

public Article getFirstJavaArticle() {

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

Ngayon, lutasin natin ang problema gamit ang mga operasyon mula sa Stream API.

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

Medyo cool, hindi ba? Una naming ginagamit ang operasyon filterupang mahanap ang lahat ng mga artikulo na may tag na "Java", pagkatapos ay ginagamit namin findFirst()upang makuha ang unang paglitaw. Dahil tamad ang mga stream at nagbabalik ng stream ang filter, ipoproseso lang ng diskarteng ito ang mga elemento hanggang sa makita nito ang unang tugma. Ngayon, kunin natin ang lahat ng artikulong may tag na “Java” sa halip na ang una lang. Una ang solusyon gamit ang mga loop.

public List<Article> getAllJavaArticles() {

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

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

Solusyon gamit ang mga pagpapatakbo ng stream.

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

Sa halimbawang ito, gumamit kami ng operasyon collectupang paikliin ang resultang stream, sa halip na magdeklara ng koleksyon at tahasang idagdag ang mga entry na tumutugma. So far so good. Oras na para sa mga halimbawa na talagang magpapakinang sa Stream API. Igrupo natin ang lahat ng artikulo ayon sa may-akda. Gaya ng dati, nagsisimula kami sa pamamagitan ng paglutas nito gamit ang mga loop:

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;
}

Makakahanap ba tayo ng malinis na solusyon sa problemang ito gamit ang mga pagpapatakbo ng stream?

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

Kahanga-hanga! Sa pamamagitan ng paggamit ng isang operasyon groupingByat isang sanggunian ng pamamaraan getAuthor(), nakakakuha kami ng malinis at nababasang code. Ngayon, hanapin natin ang iba pang mga tag na ginamit sa koleksyon. Magsimula tayo sa isang halimbawa ng loop:

public Set<String> getDistinctTags() {

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

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

Okay, tingnan natin kung paano natin ito malulutas gamit ang mga pagpapatakbo ng stream:

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

Malamig! flatmaptumutulong sa amin na i-flat ang listahan ng mga tag sa isang stream ng resulta, na pagkatapos ay gagamitin namin collectupang gawin ang return set.

Walang katapusang Posibilidad

Ito ay 4 na halimbawa kung paano mapapalitan ang mga loop ng mas nababasang code. Siguraduhing tingnan ang Stream API, dahil scratched lang ang artikulong ito. Ang pag-master ng bagong functional na istilo ng Java ay magiging isang hamon para sa mga developer ng OOP, ngunit ito ay isang hamon na dapat tanggapin nang mabuti. Pupunta pa ako at sasabihin na dapat kang matuto ng purong functional programming language. Sa ganitong paraan, lubos mong mauunawaan ang mga kakayahan at kapangyarihang ibinibigay nito. Sa tingin ko ito ay makakatulong sa iyo na maunawaan ang functional programming sa ibang antas. Kaya matuto ng functional programming kasama ng magandang lumang OOP, at gamitin ang mga ito para magsulat ng mas malaking code! Isang libreng halo ng mga pagsasalin ng dalawang artikulo - Bakit dapat mong yakapin ang functional programming sa Java 8 at Swerving Away from Loops in Java 8